dlls/sapi/token.c

   1 /*
   2  * Speech API (SAPI) token implementation.
   3  *
   4  * Copyright (C) 2017 Huw Davies
   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 #include <stdarg.h>
  22 #include <stdint.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29 #include "sapiddk.h"
  30 #include "sperror.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "sapi_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(sapi);
  37
  38 struct data_key
  39 {
  40     ISpRegDataKey ISpRegDataKey_iface;
  41     LONG ref;
  42
  43     HKEY key;
  44 };
  45
  46 static struct data_key *impl_from_ISpRegDataKey( ISpRegDataKey *iface )
  47 {
  48     return CONTAINING_RECORD( iface, struct data_key, ISpRegDataKey_iface );
  49 }
  50
  51 struct object_token
  52 {
  53     ISpObjectToken ISpObjectToken_iface;
  54     LONG ref;
  55
  56     ISpRegDataKey *data_key;
  57     WCHAR *token_id;
  58 };
  59
  60 static struct object_token *impl_from_ISpObjectToken( ISpObjectToken *iface )
  61 {
  62     return CONTAINING_RECORD( iface, struct object_token, ISpObjectToken_iface );
  63 }
  64
  65 static HRESULT WINAPI data_key_QueryInterface( ISpRegDataKey *iface, REFIID iid, void **obj )
  66 {
  67     struct data_key *This = impl_from_ISpRegDataKey( iface );
  68
  69     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
  70
  71     if (IsEqualIID( iid, &IID_IUnknown ) ||
  72         IsEqualIID( iid, &IID_ISpDataKey ) ||
  73         IsEqualIID( iid, &IID_ISpRegDataKey ))
  74     {
  75         ISpRegDataKey_AddRef( iface );
  76         *obj = iface;
  77         return S_OK;
  78     }
  79
  80     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
  81     *obj = NULL;
  82     return E_NOINTERFACE;
  83 }
  84
  85 static ULONG WINAPI data_key_AddRef( ISpRegDataKey *iface )
  86 {
  87     struct data_key *This = impl_from_ISpRegDataKey( iface );
  88     ULONG ref = InterlockedIncrement( &This->ref );
  89
  90     TRACE( "(%p) ref = %lu\n", This, ref );
  91     return ref;
  92 }
  93
  94 static ULONG WINAPI data_key_Release( ISpRegDataKey *iface )
  95 {
  96     struct data_key *This = impl_from_ISpRegDataKey( iface );
  97     ULONG ref = InterlockedDecrement(&This->ref);
  98
  99     TRACE( "(%p) ref = %lu\n", This, ref );
 100
 101     if (!ref)
 102     {
 103         if (This->key) RegCloseKey( This->key );
 104         free( This );
 105     }
 106
 107     return ref;
 108 }
 109
 110 static HRESULT WINAPI data_key_SetData( ISpRegDataKey *iface, LPCWSTR name,
 111                                         ULONG size, const BYTE *data )
 112 {
 113     FIXME( "stub\n" );
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI data_key_GetData( ISpRegDataKey *iface, LPCWSTR name,
 118                                         ULONG *size, BYTE *data )
 119 {
 120     FIXME( "stub\n" );
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI data_key_SetStringValue( ISpRegDataKey *iface,
 125                                                LPCWSTR name, LPCWSTR value )
 126 {
 127     struct data_key *This = impl_from_ISpRegDataKey( iface );
 128     DWORD ret, size;
 129
 130     TRACE( "%p, %s, %s\n", This, debugstr_w(name), debugstr_w(value) );
 131
 132     if (!This->key)
 133         return E_HANDLE;
 134
 135     size = (wcslen(value) + 1) * sizeof(WCHAR);
 136     ret = RegSetValueExW( This->key, name, 0, REG_SZ, (BYTE *)value, size );
 137
 138     return HRESULT_FROM_WIN32(ret);
 139 }
 140
 141 static HRESULT WINAPI data_key_GetStringValue( ISpRegDataKey *iface,
 142                                                LPCWSTR name, LPWSTR *value )
 143 {
 144     struct data_key *This = impl_from_ISpRegDataKey( iface );
 145     DWORD ret, size;
 146     WCHAR *content;
 147
 148     TRACE( "%p, %s, %p\n", This, debugstr_w(name), value);
 149
 150     if (!This->key)
 151         return E_HANDLE;
 152
 153     size = 0;
 154     ret = RegGetValueW( This->key, NULL, name, RRF_RT_REG_SZ, NULL, NULL, &size );
 155     if (ret != ERROR_SUCCESS)
 156         return SPERR_NOT_FOUND;
 157
 158     content = CoTaskMemAlloc(size);
 159     if (!content)
 160         return E_OUTOFMEMORY;
 161
 162     ret = RegGetValueW( This->key, NULL, name, RRF_RT_REG_SZ, NULL, content, &size );
 163     if (ret != ERROR_SUCCESS)
 164     {
 165         CoTaskMemFree(content);
 166         return HRESULT_FROM_WIN32(ret);
 167     }
 168
 169     *value = content;
 170     return S_OK;
 171 }
 172
 173 static HRESULT WINAPI data_key_SetDWORD( ISpRegDataKey *iface,
 174                                          LPCWSTR name, DWORD value )
 175 {
 176     FIXME( "stub\n" );
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI data_key_GetDWORD( ISpRegDataKey *iface,
 181                                          LPCWSTR name, DWORD *pdwValue )
 182 {
 183     FIXME( "stub\n" );
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI data_key_OpenKey( ISpRegDataKey *iface,
 188                                         LPCWSTR name, ISpDataKey **sub_key )
 189 {
 190     struct data_key *This = impl_from_ISpRegDataKey( iface );
 191     ISpRegDataKey *spregkey;
 192     HRESULT hr;
 193     HKEY key;
 194     LONG ret;
 195
 196     TRACE( "%p, %s, %p\n", This, debugstr_w(name), sub_key );
 197
 198     ret = RegOpenKeyExW( This->key, name, 0, KEY_ALL_ACCESS, &key );
 199     if (ret != ERROR_SUCCESS)
 200         return SPERR_NOT_FOUND;
 201
 202     hr = data_key_create( NULL, &IID_ISpRegDataKey, (void**)&spregkey );
 203     if (FAILED(hr))
 204     {
 205         RegCloseKey( key );
 206         return hr;
 207     }
 208
 209     hr = ISpRegDataKey_SetKey( spregkey, key, FALSE );
 210     if (FAILED(hr))
 211     {
 212         RegCloseKey( key );
 213         ISpRegDataKey_Release( spregkey );
 214         return hr;
 215     }
 216
 217     hr = ISpRegDataKey_QueryInterface( spregkey, &IID_ISpDataKey, (void**)sub_key );
 218     ISpRegDataKey_Release( spregkey );
 219
 220     return hr;
 221 }
 222
 223 static HRESULT WINAPI data_key_CreateKey( ISpRegDataKey *iface,
 224                                           LPCWSTR name, ISpDataKey **sub_key )
 225 {
 226     struct data_key *This = impl_from_ISpRegDataKey( iface );
 227     ISpRegDataKey *spregkey;
 228     HRESULT hr;
 229     HKEY key;
 230     LONG res;
 231
 232     TRACE( "%p, %s, %p\n", This, debugstr_w(name), sub_key );
 233
 234     res = RegCreateKeyExW( This->key, name, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );
 235     if (res != ERROR_SUCCESS)
 236         return HRESULT_FROM_WIN32(res);
 237
 238     hr = data_key_create(NULL, &IID_ISpRegDataKey, (void**)&spregkey);
 239     if (SUCCEEDED(hr))
 240     {
 241         hr = ISpRegDataKey_SetKey(spregkey, key, FALSE);
 242         if (SUCCEEDED(hr))
 243             hr = ISpRegDataKey_QueryInterface(spregkey, &IID_ISpDataKey, (void**)sub_key);
 244         ISpRegDataKey_Release(spregkey);
 245     }
 246
 247     return hr;
 248 }
 249
 250 static HRESULT WINAPI data_key_DeleteKey( ISpRegDataKey *iface, LPCWSTR name )
 251 {
 252     FIXME( "stub\n" );
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI data_key_DeleteValue( ISpRegDataKey *iface, LPCWSTR name )
 257 {
 258     FIXME( "stub\n" );
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI data_key_EnumKeys( ISpRegDataKey *iface,
 263                                          ULONG index, LPWSTR *sub_key )
 264 {
 265     FIXME( "stub\n" );
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI data_key_EnumValues( ISpRegDataKey *iface,
 270                                            ULONG index, LPWSTR *value )
 271 {
 272     FIXME( "stub\n" );
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI data_key_SetKey( ISpRegDataKey *iface,
 277                                        HKEY key, BOOL read_only )
 278 {
 279     struct data_key *This = impl_from_ISpRegDataKey( iface );
 280
 281     TRACE( "(%p)->(%p %d)\n", This, key, read_only );
 282
 283     if (This->key) return SPERR_ALREADY_INITIALIZED;
 284
 285     /* read_only is ignored in Windows implementations. */
 286     This->key = key;
 287     return S_OK;
 288 }
 289
 290 const struct ISpRegDataKeyVtbl data_key_vtbl =
 291 {
 292     data_key_QueryInterface,
 293     data_key_AddRef,
 294     data_key_Release,
 295     data_key_SetData,
 296     data_key_GetData,
 297     data_key_SetStringValue,
 298     data_key_GetStringValue,
 299     data_key_SetDWORD,
 300     data_key_GetDWORD,
 301     data_key_OpenKey,
 302     data_key_CreateKey,
 303     data_key_DeleteKey,
 304     data_key_DeleteValue,
 305     data_key_EnumKeys,
 306     data_key_EnumValues,
 307     data_key_SetKey
 308 };
 309
 310 HRESULT data_key_create( IUnknown *outer, REFIID iid, void **obj )
 311 {
 312     struct data_key *This = malloc( sizeof(*This) );
 313     HRESULT hr;
 314
 315     if (!This) return E_OUTOFMEMORY;
 316     This->ISpRegDataKey_iface.lpVtbl = &data_key_vtbl;
 317     This->ref = 1;
 318     This->key = NULL;
 319
 320     hr = ISpRegDataKey_QueryInterface( &This->ISpRegDataKey_iface, iid, obj );
 321
 322     ISpRegDataKey_Release( &This->ISpRegDataKey_iface );
 323     return hr;
 324 }
 325
 326 struct token_category
 327 {
 328     ISpObjectTokenCategory ISpObjectTokenCategory_iface;
 329     LONG ref;
 330
 331     ISpRegDataKey *data_key;
 332     WCHAR *id;
 333 };
 334
 335 static struct token_category *impl_from_ISpObjectTokenCategory( ISpObjectTokenCategory *iface )
 336 {
 337     return CONTAINING_RECORD( iface, struct token_category, ISpObjectTokenCategory_iface );
 338 }
 339
 340 static HRESULT WINAPI token_category_QueryInterface( ISpObjectTokenCategory *iface,
 341                                                      REFIID iid, void **obj )
 342 {
 343     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 344
 345     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 346
 347     if (IsEqualIID( iid, &IID_IUnknown ) ||
 348         IsEqualIID( iid, &IID_ISpDataKey ) ||
 349         IsEqualIID( iid, &IID_ISpObjectTokenCategory ))
 350     {
 351         ISpObjectTokenCategory_AddRef( iface );
 352         *obj = iface;
 353         return S_OK;
 354     }
 355
 356     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 357     *obj = NULL;
 358     return E_NOINTERFACE;
 359 }
 360
 361 static ULONG WINAPI token_category_AddRef( ISpObjectTokenCategory *iface )
 362 {
 363     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 364     ULONG ref = InterlockedIncrement( &This->ref );
 365
 366     TRACE( "(%p) ref = %lu\n", This, ref );
 367     return ref;
 368 }
 369
 370 static ULONG WINAPI token_category_Release( ISpObjectTokenCategory *iface )
 371 {
 372     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 373     ULONG ref = InterlockedDecrement(&This->ref);
 374
 375     TRACE( "(%p) ref = %lu\n", This, ref );
 376
 377     if (!ref)
 378     {
 379         if (This->data_key) ISpRegDataKey_Release( This->data_key );
 380         free( This->id );
 381         free( This );
 382     }
 383     return ref;
 384 }
 385
 386 static HRESULT WINAPI token_category_SetData( ISpObjectTokenCategory *iface,
 387                                               LPCWSTR name, ULONG size,
 388                                               const BYTE *data )
 389 {
 390     FIXME( "stub\n" );
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI token_category_GetData( ISpObjectTokenCategory *iface,
 395                                               LPCWSTR name, ULONG *size,
 396                                               BYTE *data )
 397 {
 398     FIXME( "stub\n" );
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI token_category_SetStringValue( ISpObjectTokenCategory *iface,
 403                                                      LPCWSTR name, LPCWSTR value )
 404 {
 405     FIXME( "stub\n" );
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI token_category_GetStringValue( ISpObjectTokenCategory *iface,
 410                                                      LPCWSTR name, LPWSTR *value )
 411 {
 412     FIXME( "stub\n" );
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI token_category_SetDWORD( ISpObjectTokenCategory *iface,
 417                                                LPCWSTR name, DWORD value )
 418 {
 419     FIXME( "stub\n" );
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI token_category_GetDWORD( ISpObjectTokenCategory *iface,
 424                                                LPCWSTR name, DWORD *pdwValue )
 425 {
 426     FIXME( "stub\n" );
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI token_category_OpenKey( ISpObjectTokenCategory *iface,
 431                                               LPCWSTR name, ISpDataKey **sub_key )
 432 {
 433     FIXME( "stub\n" );
 434     return E_NOTIMPL;
 435 }
 436
 437 static HRESULT WINAPI token_category_CreateKey( ISpObjectTokenCategory *iface,
 438                                                 LPCWSTR name, ISpDataKey **sub_key )
 439 {
 440     FIXME( "stub\n" );
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI token_category_DeleteKey( ISpObjectTokenCategory *iface,
 445                                                 LPCWSTR name )
 446 {
 447     FIXME( "stub\n" );
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI token_category_DeleteValue( ISpObjectTokenCategory *iface,
 452                                                   LPCWSTR name )
 453 {
 454     FIXME( "stub\n" );
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI token_category_EnumKeys( ISpObjectTokenCategory *iface,
 459                                                ULONG index, LPWSTR *sub_key )
 460 {
 461     FIXME( "stub\n" );
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI token_category_EnumValues( ISpObjectTokenCategory *iface,
 466                                                  ULONG index, LPWSTR *value )
 467 {
 468     FIXME( "stub\n" );
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT parse_cat_id( const WCHAR *str, HKEY *root, const WCHAR **sub_key )
 473 {
 474     struct table
 475     {
 476         const WCHAR *name;
 477         unsigned int len;
 478         HKEY key;
 479     } table[] =
 480     {
 481 #define X(s)  s, ARRAY_SIZE(s) - 1
 482         { X(L"HKEY_LOCAL_MACHINE\\"), HKEY_LOCAL_MACHINE },
 483         { X(L"HKEY_CURRENT_USER\\"), HKEY_CURRENT_USER },
 484         { NULL }
 485 #undef X
 486     };
 487     struct table *ptr;
 488     int len = lstrlenW( str );
 489
 490     for (ptr = table; ptr->name; ptr++)
 491     {
 492         if (len >= ptr->len && !wcsncmp( str, ptr->name, ptr->len ))
 493         {
 494             *root = ptr->key;
 495             *sub_key = str + ptr->len;
 496             return S_OK;
 497         }
 498     }
 499     return S_FALSE;
 500 }
 501
 502 static HRESULT WINAPI create_data_key_with_hkey( HKEY key, ISpRegDataKey **data_key )
 503 {
 504     HRESULT hr;
 505
 506     if (FAILED(hr = CoCreateInstance( &CLSID_SpDataKey, NULL, CLSCTX_INPROC_SERVER,
 507                                       &IID_ISpRegDataKey, (void **)data_key ) ))
 508         return hr;
 509
 510     if (FAILED(hr = ISpRegDataKey_SetKey( *data_key, key, TRUE )))
 511     {
 512         ISpRegDataKey_Release( *data_key );
 513         *data_key = NULL;
 514     }
 515
 516     return hr;
 517 }
 518
 519 static HRESULT WINAPI token_category_SetId( ISpObjectTokenCategory *iface,
 520                                             LPCWSTR id, BOOL create )
 521 {
 522     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 523     HKEY root, key;
 524     const WCHAR *subkey;
 525     LONG res;
 526     HRESULT hr;
 527
 528     TRACE( "(%p)->(%s %d)\n", This, debugstr_w( id ), create );
 529
 530     if (This->data_key) return SPERR_ALREADY_INITIALIZED;
 531
 532     hr = parse_cat_id( id, &root, &subkey );
 533     if (hr != S_OK) return SPERR_INVALID_REGISTRY_KEY;
 534
 535     if (create)
 536         res = RegCreateKeyExW( root, subkey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );
 537     else
 538         res = RegOpenKeyExW( root, subkey, 0, KEY_ALL_ACCESS, &key );
 539     if (res) return SPERR_INVALID_REGISTRY_KEY;
 540
 541     if (FAILED(hr = create_data_key_with_hkey( key, &This->data_key )))
 542     {
 543         RegCloseKey( key );
 544         return hr;
 545     }
 546
 547     This->id = wcsdup( id );
 548
 549     return hr;
 550 }
 551
 552 static HRESULT WINAPI token_category_GetId( ISpObjectTokenCategory *iface,
 553                                             LPWSTR *id )
 554 {
 555     FIXME( "stub\n" );
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI token_category_GetDataKey( ISpObjectTokenCategory *iface,
 560                                                  SPDATAKEYLOCATION location,
 561                                                  ISpDataKey **data_key )
 562 {
 563     FIXME( "stub\n" );
 564     return E_NOTIMPL;
 565 }
 566
 567 struct token_with_score
 568 {
 569     ISpObjectToken *token;
 570     uint64_t score;
 571 };
 572
 573 struct token_enum
 574 {
 575     ISpObjectTokenEnumBuilder ISpObjectTokenEnumBuilder_iface;
 576     LONG ref;
 577
 578     BOOL init;
 579     WCHAR *req, *opt;
 580     struct token_with_score *tokens;
 581     ULONG capacity, count;
 582     DWORD index;
 583 };
 584
 585 static struct token_enum *impl_from_ISpObjectTokenEnumBuilder( ISpObjectTokenEnumBuilder *iface )
 586 {
 587     return CONTAINING_RECORD( iface, struct token_enum, ISpObjectTokenEnumBuilder_iface );
 588 }
 589
 590 static HRESULT WINAPI token_category_EnumTokens( ISpObjectTokenCategory *iface,
 591                                                  LPCWSTR req, LPCWSTR opt,
 592                                                  IEnumSpObjectTokens **enum_tokens )
 593 {
 594     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 595     ISpObjectTokenEnumBuilder *builder;
 596     struct data_key *this_data_key;
 597     HKEY tokens_key;
 598     DWORD count, max_subkey_size, root_len, token_id_size;
 599     DWORD size, i;
 600     WCHAR *token_id = NULL;
 601     ISpObjectToken *token = NULL;
 602     HRESULT hr;
 603
 604     TRACE( "(%p)->(%s %s %p)\n", This, debugstr_w( req ), debugstr_w( opt ), enum_tokens );
 605
 606     if (!This->data_key) return SPERR_UNINITIALIZED;
 607
 608     hr = CoCreateInstance( &CLSID_SpObjectTokenEnum, NULL, CLSCTX_ALL,
 609                            &IID_ISpObjectTokenEnumBuilder, (void **)&builder );
 610     if (FAILED(hr)) return hr;
 611
 612     hr = ISpObjectTokenEnumBuilder_SetAttribs( builder, req, opt );
 613     if (FAILED(hr)) goto fail;
 614
 615     this_data_key = impl_from_ISpRegDataKey( This->data_key );
 616
 617     if (!RegOpenKeyExW( this_data_key->key, L"Tokens", 0, KEY_ALL_ACCESS, &tokens_key ))
 618     {
 619         RegQueryInfoKeyW( tokens_key, NULL, NULL, NULL, &count, &max_subkey_size, NULL,
 620                 NULL, NULL, NULL, NULL, NULL );
 621         max_subkey_size++;
 622
 623         root_len = wcslen( This->id );
 624         token_id_size = root_len + sizeof("\\Tokens\\") + max_subkey_size;
 625         token_id = malloc( token_id_size * sizeof(WCHAR) );
 626         if (!token_id)
 627         {
 628             hr = E_OUTOFMEMORY;
 629             goto fail;
 630         }
 631         root_len = swprintf( token_id, token_id_size, L"%ls%lsTokens\\",
 632                              This->id, This->id[root_len - 1] == L'\\' ? L"" : L"\\" );
 633
 634         for ( i = 0; i < count; i++ )
 635         {
 636             size = max_subkey_size;
 637             hr = HRESULT_FROM_WIN32(RegEnumKeyExW( tokens_key, i, token_id + root_len, &size, NULL, NULL, NULL, NULL ));
 638             if (FAILED(hr)) goto fail;
 639
 640             hr = token_create( NULL, &IID_ISpObjectToken, (void **)&token );
 641             if (FAILED(hr)) goto fail;
 642
 643             hr = ISpObjectToken_SetId( token, NULL, token_id, FALSE );
 644             if (FAILED(hr)) goto fail;
 645
 646             hr = ISpObjectTokenEnumBuilder_AddTokens( builder, 1, &token );
 647             if (FAILED(hr)) goto fail;
 648             ISpObjectToken_Release( token );
 649             token = NULL;
 650         }
 651
 652         hr = ISpObjectTokenEnumBuilder_Sort( builder, NULL );
 653         if (FAILED(hr)) goto fail;
 654     }
 655
 656     hr = ISpObjectTokenEnumBuilder_QueryInterface( builder, &IID_IEnumSpObjectTokens,
 657                                                    (void **)enum_tokens );
 658
 659 fail:
 660     ISpObjectTokenEnumBuilder_Release( builder );
 661     if ( token ) ISpObjectToken_Release( token );
 662     free( token_id );
 663     return hr;
 664 }
 665
 666 static HRESULT WINAPI token_category_SetDefaultTokenId( ISpObjectTokenCategory *iface,
 667                                                         LPCWSTR id )
 668 {
 669     FIXME( "stub\n" );
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI token_category_GetDefaultTokenId( ISpObjectTokenCategory *iface,
 674                                                         LPWSTR *id )
 675 {
 676     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 677     struct data_key *this_data_key;
 678     LONG res;
 679     WCHAR regvalue[512];
 680     DWORD regvalue_size = sizeof( regvalue );
 681
 682     FIXME( "(%p)->(%p): semi-stub\n", iface, id );
 683
 684     if (!This->data_key)
 685         return SPERR_UNINITIALIZED;
 686
 687     if (!id)
 688         return E_POINTER;
 689
 690     /* todo: check HKCU's DefaultTokenId before */
 691
 692     this_data_key = impl_from_ISpRegDataKey( This->data_key );
 693
 694     res = RegGetValueW( this_data_key->key, NULL, L"DefaultDefaultTokenId", RRF_RT_REG_SZ,
 695                         NULL, &regvalue, &regvalue_size);
 696     if (res == ERROR_FILE_NOT_FOUND) {
 697         return SPERR_NOT_FOUND;
 698     } else if (res != ERROR_SUCCESS) {
 699         /* probably not the correct return value */
 700         FIXME( "returning %08lx\n", res );
 701         return res;
 702     }
 703
 704     *id = CoTaskMemAlloc( regvalue_size );
 705     wcscpy( *id, regvalue );
 706
 707     return S_OK;
 708 }
 709
 710 const struct ISpObjectTokenCategoryVtbl token_category_vtbl =
 711 {
 712     token_category_QueryInterface,
 713     token_category_AddRef,
 714     token_category_Release,
 715     token_category_SetData,
 716     token_category_GetData,
 717     token_category_SetStringValue,
 718     token_category_GetStringValue,
 719     token_category_SetDWORD,
 720     token_category_GetDWORD,
 721     token_category_OpenKey,
 722     token_category_CreateKey,
 723     token_category_DeleteKey,
 724     token_category_DeleteValue,
 725     token_category_EnumKeys,
 726     token_category_EnumValues,
 727     token_category_SetId,
 728     token_category_GetId,
 729     token_category_GetDataKey,
 730     token_category_EnumTokens,
 731     token_category_SetDefaultTokenId,
 732     token_category_GetDefaultTokenId,
 733 };
 734
 735 HRESULT token_category_create( IUnknown *outer, REFIID iid, void **obj )
 736 {
 737     struct token_category *This = malloc( sizeof(*This) );
 738     HRESULT hr;
 739
 740     if (!This) return E_OUTOFMEMORY;
 741     This->ISpObjectTokenCategory_iface.lpVtbl = &token_category_vtbl;
 742     This->ref = 1;
 743     This->data_key = NULL;
 744     This->id = NULL;
 745
 746     hr = ISpObjectTokenCategory_QueryInterface( &This->ISpObjectTokenCategory_iface, iid, obj );
 747
 748     ISpObjectTokenCategory_Release( &This->ISpObjectTokenCategory_iface );
 749     return hr;
 750 }
 751
 752 static HRESULT WINAPI token_enum_QueryInterface( ISpObjectTokenEnumBuilder *iface,
 753                                                  REFIID iid, void **obj )
 754 {
 755     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 756
 757     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 758
 759     if (IsEqualIID( iid, &IID_IUnknown ) ||
 760         IsEqualIID( iid, &IID_IEnumSpObjectTokens ) ||
 761         IsEqualIID( iid, &IID_ISpObjectTokenEnumBuilder ))
 762     {
 763         ISpObjectTokenEnumBuilder_AddRef( iface );
 764         *obj = iface;
 765         return S_OK;
 766     }
 767
 768     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 769     *obj = NULL;
 770     return E_NOINTERFACE;
 771 }
 772
 773 static ULONG WINAPI token_enum_AddRef( ISpObjectTokenEnumBuilder *iface )
 774 {
 775     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 776     ULONG ref = InterlockedIncrement( &This->ref );
 777
 778     TRACE( "(%p) ref = %lu\n", This, ref );
 779     return ref;
 780 }
 781
 782 static ULONG WINAPI token_enum_Release( ISpObjectTokenEnumBuilder *iface )
 783 {
 784     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 785     ULONG ref = InterlockedDecrement(&This->ref);
 786
 787     TRACE( "(%p) ref = %lu\n", This, ref );
 788
 789     if (!ref)
 790     {
 791         free( This->req );
 792         free( This->opt );
 793         if (This->tokens)
 794         {
 795             ULONG i;
 796             for ( i = 0; i < This->count; i++ )
 797                 if ( This->tokens[i].token )
 798                     ISpObjectToken_Release( This->tokens[i].token );
 799             free( This->tokens );
 800         }
 801         free( This );
 802     }
 803
 804     return ref;
 805 }
 806
 807 static HRESULT WINAPI token_enum_Next( ISpObjectTokenEnumBuilder *iface,
 808                                        ULONG num, ISpObjectToken **tokens,
 809                                        ULONG *fetched )
 810 {
 811     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 812     ULONG i;
 813
 814     TRACE( "(%p)->(%lu %p %p)\n", This, num, tokens, fetched );
 815
 816     if (!This->init) return SPERR_UNINITIALIZED;
 817     if (!fetched && num != 1) return E_POINTER;
 818     if (!tokens) return E_POINTER;
 819
 820     for ( i = 0; i < num && This->index < This->count; i++, This->index++ )
 821     {
 822         ISpObjectToken_AddRef( This->tokens[This->index].token );
 823         tokens[i] = This->tokens[This->index].token;
 824     }
 825
 826     if (fetched) *fetched = i;
 827
 828     return i == num ? S_OK : S_FALSE;
 829 }
 830
 831 static HRESULT WINAPI token_enum_Skip( ISpObjectTokenEnumBuilder *iface,
 832                                        ULONG num )
 833 {
 834     FIXME( "stub\n" );
 835     return E_NOTIMPL;
 836 }
 837
 838 static HRESULT WINAPI token_enum_Reset( ISpObjectTokenEnumBuilder *iface)
 839 {
 840     FIXME( "stub\n" );
 841     return E_NOTIMPL;
 842 }
 843
 844 static HRESULT WINAPI token_enum_Clone( ISpObjectTokenEnumBuilder *iface,
 845                                         IEnumSpObjectTokens **clone )
 846 {
 847     FIXME( "stub\n" );
 848     return E_NOTIMPL;
 849 }
 850
 851 static HRESULT WINAPI token_enum_Item( ISpObjectTokenEnumBuilder *iface,
 852                                        ULONG index, ISpObjectToken **token )
 853 {
 854     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 855
 856     TRACE( "(%p)->(%lu %p)\n", This, index, token );
 857
 858     if (!This->init) return SPERR_UNINITIALIZED;
 859
 860     if (!token) return E_POINTER;
 861     if (index >= This->count) return SPERR_NO_MORE_ITEMS;
 862
 863     ISpObjectToken_AddRef( This->tokens[index].token );
 864     *token = This->tokens[index].token;
 865
 866     return S_OK;
 867 }
 868
 869 static HRESULT WINAPI token_enum_GetCount( ISpObjectTokenEnumBuilder *iface,
 870                                            ULONG *count )
 871 {
 872     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 873
 874     TRACE( "(%p)->(%p)\n", This, count );
 875
 876     if (!This->init) return SPERR_UNINITIALIZED;
 877
 878     *count = This->count;
 879     return S_OK;
 880 }
 881
 882 static HRESULT WINAPI token_enum_SetAttribs( ISpObjectTokenEnumBuilder *iface,
 883                                              LPCWSTR req, LPCWSTR opt)
 884 {
 885     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 886
 887     TRACE( "(%p)->(%s %s)\n", This, debugstr_w( req ), debugstr_w( opt ) );
 888
 889     if (This->init) return SPERR_ALREADY_INITIALIZED;
 890
 891     if (req)
 892     {
 893         This->req = wcsdup( req );
 894         if (!This->req) goto out_of_mem;
 895     }
 896
 897     if (opt)
 898     {
 899         This->opt = wcsdup( opt );
 900         if (!This->opt) goto out_of_mem;
 901     }
 902
 903     This->init = TRUE;
 904     return S_OK;
 905
 906 out_of_mem:
 907     free( This->req );
 908     return E_OUTOFMEMORY;
 909 }
 910
 911 static HRESULT score_attributes( ISpObjectToken *token, const WCHAR *attrs,
 912                                  BOOL match_all, uint64_t *score )
 913 {
 914     ISpDataKey *attrs_key;
 915     WCHAR *attr, *attr_ctx, *buf;
 916     BOOL match[64];
 917     unsigned int i, j;
 918     HRESULT hr;
 919
 920     if (!attrs)
 921     {
 922         *score = 1;
 923         return S_OK;
 924     }
 925     *score = 0;
 926
 927     if (FAILED(hr = ISpObjectToken_OpenKey( token, L"Attributes", &attrs_key )))
 928         return hr == SPERR_NOT_FOUND ? S_OK : hr;
 929
 930     memset( match, 0, sizeof(match) );
 931
 932     /* attrs is a semicolon-separated list of attribute clauses.
 933      * Each clause consists of an attribute name and an optional operator and value.
 934      * The meaning of a clause depends on the operator given:
 935      *   If no operator is given, the attribute must exist.
 936      *   If the operator is '=', the attribute must contain the given value.
 937      *   If the operator is '!=', the attribute must not exist or contain the given value.
 938      */
 939     if (!(buf = wcsdup( attrs ))) return E_OUTOFMEMORY;
 940     for ( attr = wcstok_s( buf, L";", &attr_ctx ), i = 0; attr && i < 64;
 941           attr = wcstok_s( NULL, L";", &attr_ctx ), i++ )
 942     {
 943         WCHAR *p = wcspbrk( attr, L"!=" );
 944         WCHAR op = p ? *p : L'\0';
 945         WCHAR *value = NULL, *res;
 946         if ( p )
 947         {
 948             if ( op == L'=' )
 949                 value = p + 1;
 950             else if ( op == L'!' )
 951             {
 952                 if ( *(p + 1) != L'=' )
 953                 {
 954                     WARN( "invalid attr operator '!%lc'.\n", *(p + 1) );
 955                     hr = E_INVALIDARG;
 956                     goto done;
 957                 }
 958                 value = p + 2;
 959             }
 960             *p = L'\0';
 961         }
 962
 963         hr = ISpDataKey_GetStringValue( attrs_key, attr, &res );
 964         if ( p ) *p = op;
 965         if (SUCCEEDED(hr))
 966         {
 967             if ( !op )
 968                 match[i] = TRUE;
 969             else
 970             {
 971                 WCHAR *val, *val_ctx;
 972
 973                 match[i] = FALSE;
 974                 for ( val = wcstok_s( res,  L";", &val_ctx ); val && !match[i];
 975                       val = wcstok_s( NULL, L";", &val_ctx ) )
 976                     match[i] = !wcscmp( val, value );
 977
 978                 if (op == L'!') match[i] = !match[i];
 979             }
 980             CoTaskMemFree( res );
 981         }
 982         else if (hr == SPERR_NOT_FOUND)
 983         {
 984             hr = S_OK;
 985             if (op == L'!') match[i] = TRUE;
 986         }
 987         else
 988             goto done;
 989
 990         if ( match_all && !match[i] )
 991             goto done;
 992     }
 993
 994     if ( attr )
 995         hr = E_INVALIDARG;
 996     else
 997     {
 998         /* Attributes in attrs are ordered from highest to lowest priority. */
 999         for ( j = 0; j < i; j++ )
1000             if ( match[j] )
1001                 *score |= 1ULL << (i - 1 - j);
1002     }
1003
1004 done:
1005     free( buf );
1006     return hr;
1007 }
1008
1009 static BOOL grow_tokens_array( struct token_enum *This )
1010 {
1011     struct token_with_score *new_tokens;
1012     ULONG new_cap;
1013
1014     if (This->count < This->capacity) return TRUE;
1015
1016     if (This->capacity > 0)
1017     {
1018         new_cap = This->capacity * 2;
1019         new_tokens = realloc( This->tokens, new_cap * sizeof(*new_tokens) );
1020     }
1021     else
1022     {
1023         new_cap = 1;
1024         new_tokens = malloc( sizeof(*new_tokens) );
1025     }
1026
1027     if (!new_tokens) return FALSE;
1028
1029     This->tokens = new_tokens;
1030     This->capacity = new_cap;
1031     return TRUE;
1032 }
1033
1034 static HRESULT WINAPI token_enum_AddTokens( ISpObjectTokenEnumBuilder *iface,
1035                                             ULONG num, ISpObjectToken **tokens )
1036 {
1037     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
1038     ULONG i;
1039     uint64_t score;
1040     HRESULT hr;
1041
1042     TRACE( "(%p)->(%lu %p)\n", iface, num, tokens );
1043
1044     if (!This->init) return SPERR_UNINITIALIZED;
1045     if (!tokens) return E_POINTER;
1046
1047     for ( i = 0; i < num; i++ )
1048     {
1049         if (!tokens[i]) return E_POINTER;
1050
1051         hr = score_attributes( tokens[i], This->req, TRUE, &score );
1052         if (FAILED(hr)) return hr;
1053         if (!score) continue;
1054
1055         hr = score_attributes( tokens[i], This->opt, FALSE, &score );
1056         if (FAILED(hr)) return hr;
1057
1058         if (!grow_tokens_array( This )) return E_OUTOFMEMORY;
1059         ISpObjectToken_AddRef( tokens[i] );
1060         This->tokens[This->count].token = tokens[i];
1061         This->tokens[This->count].score = score;
1062         This->count++;
1063     }
1064
1065     return S_OK;
1066 }
1067
1068 static HRESULT WINAPI token_enum_AddTokensFromDataKey( ISpObjectTokenEnumBuilder *iface,
1069                                                        ISpDataKey *data_key,
1070                                                        LPCWSTR sub_key, LPCWSTR cat_id )
1071 {
1072     FIXME( "stub\n" );
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI token_enum_AddTokensFromTokenEnum( ISpObjectTokenEnumBuilder *iface,
1077                                                          IEnumSpObjectTokens *token_enum )
1078 {
1079     FIXME( "stub\n" );
1080     return E_NOTIMPL;
1081 }
1082
1083 static int __cdecl token_with_score_cmp( const void *a, const void *b )
1084 {
1085     const struct token_with_score *ta = a, *tb = b;
1086
1087     if (ta->score > tb->score) return -1;
1088     else if (ta->score < tb->score) return 1;
1089     else return 0;
1090 }
1091
1092 static HRESULT WINAPI token_enum_Sort( ISpObjectTokenEnumBuilder *iface,
1093                                        LPCWSTR first )
1094 {
1095     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
1096
1097     TRACE( "(%p)->(%s).\n", iface, debugstr_w(first) );
1098
1099     if (!This->init) return SPERR_UNINITIALIZED;
1100     if (!This->tokens) return S_OK;
1101
1102     if (first)
1103     {
1104         FIXME( "first != NULL is not implemented.\n" );
1105         return E_NOTIMPL;
1106     }
1107
1108     if (This->opt)
1109         qsort( This->tokens, This->count, sizeof(*This->tokens), token_with_score_cmp );
1110
1111     return S_OK;
1112 }
1113
1114 const struct ISpObjectTokenEnumBuilderVtbl token_enum_vtbl =
1115 {
1116     token_enum_QueryInterface,
1117     token_enum_AddRef,
1118     token_enum_Release,
1119     token_enum_Next,
1120     token_enum_Skip,
1121     token_enum_Reset,
1122     token_enum_Clone,
1123     token_enum_Item,
1124     token_enum_GetCount,
1125     token_enum_SetAttribs,
1126     token_enum_AddTokens,
1127     token_enum_AddTokensFromDataKey,
1128     token_enum_AddTokensFromTokenEnum,
1129     token_enum_Sort
1130 };
1131
1132 HRESULT token_enum_create( IUnknown *outer, REFIID iid, void **obj )
1133 {
1134     struct token_enum *This = malloc( sizeof(*This) );
1135     HRESULT hr;
1136
1137     if (!This) return E_OUTOFMEMORY;
1138     This->ISpObjectTokenEnumBuilder_iface.lpVtbl = &token_enum_vtbl;
1139     This->ref = 1;
1140     This->req = NULL;
1141     This->opt = NULL;
1142     This->init = FALSE;
1143     This->tokens = NULL;
1144     This->capacity = This->count = 0;
1145     This->index = 0;
1146
1147     hr = ISpObjectTokenEnumBuilder_QueryInterface( &This->ISpObjectTokenEnumBuilder_iface, iid, obj );
1148
1149     ISpObjectTokenEnumBuilder_Release( &This->ISpObjectTokenEnumBuilder_iface );
1150     return hr;
1151 }
1152
1153 static HRESULT WINAPI token_QueryInterface( ISpObjectToken *iface,
1154                                             REFIID iid, void **obj )
1155 {
1156     struct object_token *This = impl_from_ISpObjectToken( iface );
1157
1158     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
1159
1160     if (IsEqualIID( iid, &IID_IUnknown ) ||
1161         IsEqualIID( iid, &IID_ISpDataKey ) ||
1162         IsEqualIID( iid, &IID_ISpObjectToken ))
1163     {
1164         ISpObjectToken_AddRef( iface );
1165         *obj = iface;
1166         return S_OK;
1167     }
1168
1169     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
1170     *obj = NULL;
1171     return E_NOINTERFACE;
1172 }
1173
1174 static ULONG WINAPI token_AddRef( ISpObjectToken *iface )
1175 {
1176     struct object_token *This = impl_from_ISpObjectToken( iface );
1177     ULONG ref = InterlockedIncrement( &This->ref );
1178
1179     TRACE( "(%p) ref = %lu\n", This, ref );
1180     return ref;
1181 }
1182
1183 static ULONG WINAPI token_Release( ISpObjectToken *iface )
1184 {
1185     struct object_token *This = impl_from_ISpObjectToken( iface );
1186     ULONG ref = InterlockedDecrement(&This->ref);
1187
1188     TRACE( "(%p) ref = %lu\n", This, ref );
1189
1190     if (!ref)
1191     {
1192         if (This->data_key) ISpRegDataKey_Release( This->data_key );
1193         free( This->token_id );
1194         free( This );
1195     }
1196
1197     return ref;
1198 }
1199
1200 static HRESULT WINAPI token_SetData( ISpObjectToken *iface,
1201                                      LPCWSTR name, ULONG size,
1202                                      const BYTE *data )
1203 {
1204     FIXME( "stub\n" );
1205     return E_NOTIMPL;
1206 }
1207
1208 static HRESULT WINAPI token_GetData( ISpObjectToken *iface,
1209                                      LPCWSTR name, ULONG *size,
1210                                      BYTE *data )
1211 {
1212     FIXME( "stub\n" );
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI token_SetStringValue( ISpObjectToken *iface,
1217                                             LPCWSTR name, LPCWSTR value )
1218 {
1219     struct object_token *This = impl_from_ISpObjectToken( iface );
1220
1221     TRACE( "%p, %s, %s\n", This, debugstr_w(name), debugstr_w(value) );
1222
1223     return ISpRegDataKey_SetStringValue( This->data_key, name, value );
1224 }
1225
1226 static HRESULT WINAPI token_GetStringValue( ISpObjectToken *iface,
1227                                             LPCWSTR name, LPWSTR *value )
1228 {
1229     struct object_token *This = impl_from_ISpObjectToken( iface );
1230
1231     TRACE( "%p, %s, %p\n", This, debugstr_w(name), value );
1232
1233     return ISpRegDataKey_GetStringValue( This->data_key, name, value );
1234 }
1235
1236 static HRESULT WINAPI token_SetDWORD( ISpObjectToken *iface,
1237                                       LPCWSTR name, DWORD value )
1238 {
1239     FIXME( "stub\n" );
1240     return E_NOTIMPL;
1241 }
1242
1243 static HRESULT WINAPI token_GetDWORD( ISpObjectToken *iface,
1244                                       LPCWSTR name, DWORD *pdwValue )
1245 {
1246     FIXME( "stub\n" );
1247     return E_NOTIMPL;
1248 }
1249
1250 static HRESULT WINAPI token_OpenKey( ISpObjectToken *iface,
1251                                      LPCWSTR name, ISpDataKey **sub_key )
1252 {
1253     struct object_token *This = impl_from_ISpObjectToken( iface );
1254
1255     TRACE( "%p, %s, %p\n", This, debugstr_w(name), sub_key );
1256
1257     return ISpRegDataKey_OpenKey( This->data_key, name, sub_key );
1258 }
1259
1260 static HRESULT WINAPI token_CreateKey( ISpObjectToken *iface,
1261                                        LPCWSTR name, ISpDataKey **sub_key )
1262 {
1263     struct object_token *This = impl_from_ISpObjectToken( iface );
1264
1265     TRACE( "%p, %s, %p\n", iface, debugstr_w(name), sub_key );
1266
1267     return ISpRegDataKey_CreateKey( This->data_key, name, sub_key );
1268 }
1269
1270 static HRESULT WINAPI token_DeleteKey( ISpObjectToken *iface,
1271                                        LPCWSTR name )
1272 {
1273     FIXME( "stub\n" );
1274     return E_NOTIMPL;
1275 }
1276
1277 static HRESULT WINAPI token_DeleteValue( ISpObjectToken *iface,
1278                                          LPCWSTR name )
1279 {
1280     FIXME( "stub\n" );
1281     return E_NOTIMPL;
1282 }
1283
1284 static HRESULT WINAPI token_EnumKeys( ISpObjectToken *iface,
1285                                       ULONG index, LPWSTR *sub_key )
1286 {
1287     FIXME( "stub\n" );
1288     return E_NOTIMPL;
1289 }
1290
1291 static HRESULT WINAPI token_EnumValues( ISpObjectToken *iface,
1292                                         ULONG index, LPWSTR *value )
1293 {
1294     FIXME( "stub\n" );
1295     return E_NOTIMPL;
1296 }
1297
1298 static HRESULT WINAPI token_SetId( ISpObjectToken *iface,
1299                                    LPCWSTR category_id, LPCWSTR token_id,
1300                                    BOOL create )
1301 {
1302     struct object_token *This = impl_from_ISpObjectToken( iface );
1303     BOOL res;
1304     HRESULT hr;
1305     HKEY root, key;
1306     const WCHAR *subkey;
1307
1308     TRACE( "(%p)->(%s %s %d)\n", This, debugstr_w( category_id ),
1309            debugstr_w(token_id), create );
1310
1311     if (This->data_key) return SPERR_ALREADY_INITIALIZED;
1312
1313     if (!token_id) return E_POINTER;
1314
1315     hr = parse_cat_id( token_id, &root, &subkey );
1316     if (hr != S_OK) return SPERR_NOT_FOUND;
1317
1318     if (create)
1319         res = RegCreateKeyExW( root, subkey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL);
1320     else
1321         res = RegOpenKeyExW( root, subkey, 0, KEY_ALL_ACCESS, &key );
1322     if (res) return SPERR_NOT_FOUND;
1323
1324     hr = create_data_key_with_hkey( key, &This->data_key );
1325     if (FAILED(hr))
1326     {
1327         RegCloseKey( key );
1328         return hr;
1329     }
1330
1331     This->token_id = wcsdup(token_id);
1332
1333     return S_OK;
1334 }
1335
1336 static HRESULT WINAPI token_GetId( ISpObjectToken *iface,
1337                                    LPWSTR *token_id )
1338 {
1339     struct object_token *This = impl_from_ISpObjectToken( iface );
1340
1341     TRACE( "%p, %p\n", This, token_id);
1342
1343     if (!This->data_key)
1344         return SPERR_UNINITIALIZED;
1345
1346     if (!token_id)
1347         return E_POINTER;
1348
1349     if (!This->token_id)
1350     {
1351         FIXME("Loading default category not supported.\n");
1352         return E_POINTER;
1353     }
1354
1355     *token_id = CoTaskMemAlloc( (wcslen(This->token_id) + 1) * sizeof(WCHAR));
1356     if (!*token_id)
1357         return E_OUTOFMEMORY;
1358
1359     wcscpy(*token_id, This->token_id);
1360     return S_OK;
1361 }
1362
1363 static HRESULT WINAPI token_GetCategory( ISpObjectToken *iface,
1364                                          ISpObjectTokenCategory **category )
1365 {
1366     FIXME( "stub\n" );
1367     return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI token_CreateInstance( ISpObjectToken *iface,
1371                                             IUnknown *outer,
1372                                             DWORD class_context,
1373                                             REFIID riid,
1374                                             void **object )
1375 {
1376     WCHAR *clsid_str;
1377     CLSID clsid;
1378     IUnknown *unk;
1379     ISpObjectWithToken *obj_token_iface;
1380     HRESULT hr;
1381
1382     TRACE( "%p, %p, %#lx, %s, %p\n", iface, outer, class_context, debugstr_guid( riid ), object );
1383
1384     if (FAILED(hr = ISpObjectToken_GetStringValue( iface, L"CLSID", &clsid_str )))
1385         return hr;
1386
1387     hr = CLSIDFromString( clsid_str, &clsid );
1388     CoTaskMemFree( clsid_str );
1389     if (FAILED(hr))
1390         return hr;
1391
1392     if (FAILED(hr = CoCreateInstance( &clsid, outer, class_context, &IID_IUnknown, (void **)&unk )))
1393         return hr;
1394
1395     /* Call ISpObjectWithToken::SetObjectToken if the interface is available. */
1396     if (SUCCEEDED(IUnknown_QueryInterface( unk, &IID_ISpObjectWithToken, (void **)&obj_token_iface )))
1397     {
1398         hr = ISpObjectWithToken_SetObjectToken( obj_token_iface, iface );
1399         ISpObjectWithToken_Release( obj_token_iface );
1400         if (FAILED(hr))
1401             goto done;
1402     }
1403
1404     hr = IUnknown_QueryInterface( unk, riid, object );
1405
1406 done:
1407     IUnknown_Release( unk );
1408     return hr;
1409 }
1410
1411 static HRESULT WINAPI token_GetStorageFileName( ISpObjectToken *iface,
1412                                                 REFCLSID caller,
1413                                                 LPCWSTR key_name,
1414                                                 LPCWSTR filename,
1415                                                 ULONG folder,
1416                                                 LPWSTR *filepath )
1417 {
1418     FIXME( "stub\n" );
1419     return E_NOTIMPL;
1420 }
1421
1422 static HRESULT WINAPI token_RemoveStorageFileName( ISpObjectToken *iface,
1423                                                    REFCLSID caller,
1424                                                    LPCWSTR key_name,
1425                                                    BOOL delete_file )
1426 {
1427     FIXME( "stub\n" );
1428     return E_NOTIMPL;
1429 }
1430
1431 static HRESULT WINAPI token_Remove( ISpObjectToken *iface,
1432                                     REFCLSID caller )
1433 {
1434     FIXME( "stub\n" );
1435     return E_NOTIMPL;
1436 }
1437
1438 static HRESULT WINAPI token_IsUISupported( ISpObjectToken *iface,
1439                                            LPCWSTR ui_type,
1440                                            void *extra_data,
1441                                            ULONG extra_data_size,
1442                                            IUnknown *object,
1443                                            BOOL *supported )
1444 {
1445     FIXME( "stub\n" );
1446     return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI token_DisplayUI( ISpObjectToken *iface,
1450                                        HWND parent,
1451                                        LPCWSTR title,
1452                                        LPCWSTR ui_type,
1453                                        void *extra_data,
1454                                        ULONG extra_data_size,
1455                                        IUnknown *object )
1456 {
1457     FIXME( "stub\n" );
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI token_MatchesAttributes( ISpObjectToken *iface,
1462                                                LPCWSTR attributes,
1463                                                BOOL *matches )
1464 {
1465     FIXME( "stub\n" );
1466     return E_NOTIMPL;
1467 }
1468
1469 const struct ISpObjectTokenVtbl token_vtbl =
1470 {
1471     token_QueryInterface,
1472     token_AddRef,
1473     token_Release,
1474     token_SetData,
1475     token_GetData,
1476     token_SetStringValue,
1477     token_GetStringValue,
1478     token_SetDWORD,
1479     token_GetDWORD,
1480     token_OpenKey,
1481     token_CreateKey,
1482     token_DeleteKey,
1483     token_DeleteValue,
1484     token_EnumKeys,
1485     token_EnumValues,
1486     token_SetId,
1487     token_GetId,
1488     token_GetCategory,
1489     token_CreateInstance,
1490     token_GetStorageFileName,
1491     token_RemoveStorageFileName,
1492     token_Remove,
1493     token_IsUISupported,
1494     token_DisplayUI,
1495     token_MatchesAttributes
1496 };
1497
1498 HRESULT token_create( IUnknown *outer, REFIID iid, void **obj )
1499 {
1500     struct object_token *This = malloc( sizeof(*This) );
1501     HRESULT hr;
1502
1503     if (!This) return E_OUTOFMEMORY;
1504     This->ISpObjectToken_iface.lpVtbl = &token_vtbl;
1505     This->ref = 1;
1506
1507     This->data_key = NULL;
1508     This->token_id = NULL;
1509
1510     hr = ISpObjectToken_QueryInterface( &This->ISpObjectToken_iface, iid, obj );
1511
1512     ISpObjectToken_Release( &This->ISpObjectToken_iface );
1513     return hr;
1514 }