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
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "sapiddk.h"
  29 #include "sperror.h"
  30
  31 #include "wine/debug.h"
  32
  33 #include "sapi_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(sapi);
  36
  37 struct data_key
  38 {
  39     ISpRegDataKey ISpRegDataKey_iface;
  40     LONG ref;
  41
  42     HKEY key;
  43     BOOL read_only;
  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 static HRESULT WINAPI data_key_QueryInterface( ISpRegDataKey *iface, REFIID iid, void **obj )
  52 {
  53     struct data_key *This = impl_from_ISpRegDataKey( iface );
  54
  55     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
  56
  57     if (IsEqualIID( iid, &IID_IUnknown ) ||
  58         IsEqualIID( iid, &IID_ISpDataKey ) ||
  59         IsEqualIID( iid, &IID_ISpRegDataKey ))
  60     {
  61         ISpRegDataKey_AddRef( iface );
  62         *obj = iface;
  63         return S_OK;
  64     }
  65
  66     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
  67     *obj = NULL;
  68     return E_NOINTERFACE;
  69 }
  70
  71 static ULONG WINAPI data_key_AddRef( ISpRegDataKey *iface )
  72 {
  73     struct data_key *This = impl_from_ISpRegDataKey( iface );
  74     ULONG ref = InterlockedIncrement( &This->ref );
  75
  76     TRACE( "(%p) ref = %lu\n", This, ref );
  77     return ref;
  78 }
  79
  80 static ULONG WINAPI data_key_Release( ISpRegDataKey *iface )
  81 {
  82     struct data_key *This = impl_from_ISpRegDataKey( iface );
  83     ULONG ref = InterlockedDecrement(&This->ref);
  84
  85     TRACE( "(%p) ref = %lu\n", This, ref );
  86
  87     if (!ref)
  88     {
  89         if (This->key) RegCloseKey( This->key );
  90         heap_free( This );
  91     }
  92
  93     return ref;
  94 }
  95
  96 static HRESULT WINAPI data_key_SetData( ISpRegDataKey *iface, LPCWSTR name,
  97                                         ULONG size, const BYTE *data )
  98 {
  99     FIXME( "stub\n" );
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT WINAPI data_key_GetData( ISpRegDataKey *iface, LPCWSTR name,
 104                                         ULONG *size, BYTE *data )
 105 {
 106     FIXME( "stub\n" );
 107     return E_NOTIMPL;
 108 }
 109
 110 static HRESULT WINAPI data_key_SetStringValue( ISpRegDataKey *iface,
 111                                                LPCWSTR name, LPCWSTR value )
 112 {
 113     FIXME( "stub\n" );
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI data_key_GetStringValue( ISpRegDataKey *iface,
 118                                                LPCWSTR name, LPWSTR *value )
 119 {
 120     FIXME( "stub\n" );
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI data_key_SetDWORD( ISpRegDataKey *iface,
 125                                          LPCWSTR name, DWORD value )
 126 {
 127     FIXME( "stub\n" );
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI data_key_GetDWORD( ISpRegDataKey *iface,
 132                                          LPCWSTR name, DWORD *pdwValue )
 133 {
 134     FIXME( "stub\n" );
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI data_key_OpenKey( ISpRegDataKey *iface,
 139                                         LPCWSTR name, ISpDataKey **sub_key )
 140 {
 141     FIXME( "stub\n" );
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI data_key_CreateKey( ISpRegDataKey *iface,
 146                                           LPCWSTR name, ISpDataKey **sub_key )
 147 {
 148     FIXME( "stub\n" );
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI data_key_DeleteKey( ISpRegDataKey *iface, LPCWSTR name )
 153 {
 154     FIXME( "stub\n" );
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI data_key_DeleteValue( ISpRegDataKey *iface, LPCWSTR name )
 159 {
 160     FIXME( "stub\n" );
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI data_key_EnumKeys( ISpRegDataKey *iface,
 165                                          ULONG index, LPWSTR *sub_key )
 166 {
 167     FIXME( "stub\n" );
 168     return E_NOTIMPL;
 169 }
 170
 171 static HRESULT WINAPI data_key_EnumValues( ISpRegDataKey *iface,
 172                                            ULONG index, LPWSTR *value )
 173 {
 174     FIXME( "stub\n" );
 175     return E_NOTIMPL;
 176 }
 177
 178 static HRESULT WINAPI data_key_SetKey( ISpRegDataKey *iface,
 179                                        HKEY key, BOOL read_only )
 180 {
 181     struct data_key *This = impl_from_ISpRegDataKey( iface );
 182
 183     TRACE( "(%p)->(%p %d)\n", This, key, read_only );
 184
 185     if (This->key) return SPERR_ALREADY_INITIALIZED;
 186
 187     This->key = key;
 188     This->read_only = read_only;
 189     return S_OK;
 190 }
 191
 192 const struct ISpRegDataKeyVtbl data_key_vtbl =
 193 {
 194     data_key_QueryInterface,
 195     data_key_AddRef,
 196     data_key_Release,
 197     data_key_SetData,
 198     data_key_GetData,
 199     data_key_SetStringValue,
 200     data_key_GetStringValue,
 201     data_key_SetDWORD,
 202     data_key_GetDWORD,
 203     data_key_OpenKey,
 204     data_key_CreateKey,
 205     data_key_DeleteKey,
 206     data_key_DeleteValue,
 207     data_key_EnumKeys,
 208     data_key_EnumValues,
 209     data_key_SetKey
 210 };
 211
 212 HRESULT data_key_create( IUnknown *outer, REFIID iid, void **obj )
 213 {
 214     struct data_key *This = heap_alloc( sizeof(*This) );
 215     HRESULT hr;
 216
 217     if (!This) return E_OUTOFMEMORY;
 218     This->ISpRegDataKey_iface.lpVtbl = &data_key_vtbl;
 219     This->ref = 1;
 220     This->key = NULL;
 221     This->read_only = FALSE;
 222
 223     hr = ISpRegDataKey_QueryInterface( &This->ISpRegDataKey_iface, iid, obj );
 224
 225     ISpRegDataKey_Release( &This->ISpRegDataKey_iface );
 226     return hr;
 227 }
 228
 229 struct token_category
 230 {
 231     ISpObjectTokenCategory ISpObjectTokenCategory_iface;
 232     LONG ref;
 233
 234     ISpRegDataKey *data_key;
 235 };
 236
 237 static struct token_category *impl_from_ISpObjectTokenCategory( ISpObjectTokenCategory *iface )
 238 {
 239     return CONTAINING_RECORD( iface, struct token_category, ISpObjectTokenCategory_iface );
 240 }
 241
 242 static HRESULT WINAPI token_category_QueryInterface( ISpObjectTokenCategory *iface,
 243                                                      REFIID iid, void **obj )
 244 {
 245     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 246
 247     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 248
 249     if (IsEqualIID( iid, &IID_IUnknown ) ||
 250         IsEqualIID( iid, &IID_ISpDataKey ) ||
 251         IsEqualIID( iid, &IID_ISpObjectTokenCategory ))
 252     {
 253         ISpObjectTokenCategory_AddRef( iface );
 254         *obj = iface;
 255         return S_OK;
 256     }
 257
 258     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 259     *obj = NULL;
 260     return E_NOINTERFACE;
 261 }
 262
 263 static ULONG WINAPI token_category_AddRef( ISpObjectTokenCategory *iface )
 264 {
 265     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 266     ULONG ref = InterlockedIncrement( &This->ref );
 267
 268     TRACE( "(%p) ref = %lu\n", This, ref );
 269     return ref;
 270 }
 271
 272 static ULONG WINAPI token_category_Release( ISpObjectTokenCategory *iface )
 273 {
 274     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 275     ULONG ref = InterlockedDecrement(&This->ref);
 276
 277     TRACE( "(%p) ref = %lu\n", This, ref );
 278
 279     if (!ref)
 280     {
 281         if (This->data_key) ISpRegDataKey_Release( This->data_key );
 282         heap_free( This );
 283     }
 284     return ref;
 285 }
 286
 287 static HRESULT WINAPI token_category_SetData( ISpObjectTokenCategory *iface,
 288                                               LPCWSTR name, ULONG size,
 289                                               const BYTE *data )
 290 {
 291     FIXME( "stub\n" );
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI token_category_GetData( ISpObjectTokenCategory *iface,
 296                                               LPCWSTR name, ULONG *size,
 297                                               BYTE *data )
 298 {
 299     FIXME( "stub\n" );
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI token_category_SetStringValue( ISpObjectTokenCategory *iface,
 304                                                      LPCWSTR name, LPCWSTR value )
 305 {
 306     FIXME( "stub\n" );
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI token_category_GetStringValue( ISpObjectTokenCategory *iface,
 311                                                      LPCWSTR name, LPWSTR *value )
 312 {
 313     FIXME( "stub\n" );
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI token_category_SetDWORD( ISpObjectTokenCategory *iface,
 318                                                LPCWSTR name, DWORD value )
 319 {
 320     FIXME( "stub\n" );
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI token_category_GetDWORD( ISpObjectTokenCategory *iface,
 325                                                LPCWSTR name, DWORD *pdwValue )
 326 {
 327     FIXME( "stub\n" );
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI token_category_OpenKey( ISpObjectTokenCategory *iface,
 332                                               LPCWSTR name, ISpDataKey **sub_key )
 333 {
 334     FIXME( "stub\n" );
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI token_category_CreateKey( ISpObjectTokenCategory *iface,
 339                                                 LPCWSTR name, ISpDataKey **sub_key )
 340 {
 341     FIXME( "stub\n" );
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI token_category_DeleteKey( ISpObjectTokenCategory *iface,
 346                                                 LPCWSTR name )
 347 {
 348     FIXME( "stub\n" );
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI token_category_DeleteValue( ISpObjectTokenCategory *iface,
 353                                                   LPCWSTR name )
 354 {
 355     FIXME( "stub\n" );
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI token_category_EnumKeys( ISpObjectTokenCategory *iface,
 360                                                ULONG index, LPWSTR *sub_key )
 361 {
 362     FIXME( "stub\n" );
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI token_category_EnumValues( ISpObjectTokenCategory *iface,
 367                                                  ULONG index, LPWSTR *value )
 368 {
 369     FIXME( "stub\n" );
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT parse_cat_id( const WCHAR *str, HKEY *root, const WCHAR **sub_key )
 374 {
 375     struct table
 376     {
 377         const WCHAR *name;
 378         unsigned int len;
 379         HKEY key;
 380     } table[] =
 381     {
 382 #define X(s)  s, ARRAY_SIZE(s) - 1
 383         { X(L"HKEY_LOCAL_MACHINE\\"), HKEY_LOCAL_MACHINE },
 384         { X(L"HKEY_CURRENT_USER\\"), HKEY_CURRENT_USER },
 385         { NULL }
 386 #undef X
 387     };
 388     struct table *ptr;
 389     int len = lstrlenW( str );
 390
 391     for (ptr = table; ptr->name; ptr++)
 392     {
 393         if (len >= ptr->len && !wcsncmp( str, ptr->name, ptr->len ))
 394         {
 395             *root = ptr->key;
 396             *sub_key = str + ptr->len;
 397             return S_OK;
 398         }
 399     }
 400     return S_FALSE;
 401 }
 402
 403 static HRESULT WINAPI token_category_SetId( ISpObjectTokenCategory *iface,
 404                                             LPCWSTR id, BOOL create )
 405 {
 406     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 407     HKEY root, key;
 408     const WCHAR *subkey;
 409     LONG res;
 410     HRESULT hr;
 411
 412     TRACE( "(%p)->(%s %d)\n", This, debugstr_w( id ), create );
 413
 414     if (This->data_key) return SPERR_ALREADY_INITIALIZED;
 415
 416     hr = parse_cat_id( id, &root, &subkey );
 417     if (hr != S_OK) return SPERR_INVALID_REGISTRY_KEY;
 418
 419     if (create)
 420         res = RegCreateKeyExW( root, subkey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL );
 421     else
 422         res = RegOpenKeyExW( root, subkey, 0, KEY_ALL_ACCESS, &key );
 423     if (res) return SPERR_INVALID_REGISTRY_KEY;
 424
 425     hr = CoCreateInstance( &CLSID_SpDataKey, NULL, CLSCTX_ALL,
 426                            &IID_ISpRegDataKey, (void **)&This->data_key );
 427     if (FAILED(hr)) goto fail;
 428
 429     hr = ISpRegDataKey_SetKey( This->data_key, key, FALSE );
 430     if (FAILED(hr)) goto fail;
 431
 432     return hr;
 433
 434 fail:
 435     RegCloseKey( key );
 436     return hr;
 437 }
 438
 439 static HRESULT WINAPI token_category_GetId( ISpObjectTokenCategory *iface,
 440                                             LPWSTR *id )
 441 {
 442     FIXME( "stub\n" );
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI token_category_GetDataKey( ISpObjectTokenCategory *iface,
 447                                                  SPDATAKEYLOCATION location,
 448                                                  ISpDataKey **data_key )
 449 {
 450     FIXME( "stub\n" );
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI token_category_EnumTokens( ISpObjectTokenCategory *iface,
 455                                                  LPCWSTR req, LPCWSTR opt,
 456                                                  IEnumSpObjectTokens **enum_tokens )
 457 {
 458     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 459     ISpObjectTokenEnumBuilder *builder;
 460     HRESULT hr;
 461
 462     FIXME( "(%p)->(%s %s %p): semi-stub\n", This, debugstr_w( req ), debugstr_w( opt ), enum_tokens );
 463
 464     if (!This->data_key) return SPERR_UNINITIALIZED;
 465
 466     hr = CoCreateInstance( &CLSID_SpObjectTokenEnum, NULL, CLSCTX_ALL,
 467                            &IID_ISpObjectTokenEnumBuilder, (void **)&builder );
 468     if (FAILED(hr)) return hr;
 469
 470     hr = ISpObjectTokenEnumBuilder_SetAttribs( builder, req, opt );
 471     if (FAILED(hr)) goto fail;
 472
 473     /* FIXME: Build the enumerator */
 474
 475     hr = ISpObjectTokenEnumBuilder_QueryInterface( builder, &IID_IEnumSpObjectTokens,
 476                                                    (void **)enum_tokens );
 477
 478 fail:
 479     ISpObjectTokenEnumBuilder_Release( builder );
 480     return hr;
 481 }
 482
 483 static HRESULT WINAPI token_category_SetDefaultTokenId( ISpObjectTokenCategory *iface,
 484                                                         LPCWSTR id )
 485 {
 486     FIXME( "stub\n" );
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI token_category_GetDefaultTokenId( ISpObjectTokenCategory *iface,
 491                                                         LPWSTR *id )
 492 {
 493     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 494     struct data_key *this_data_key;
 495     LONG res;
 496     WCHAR regvalue[512];
 497     DWORD regvalue_size = sizeof( regvalue );
 498
 499     FIXME( "(%p)->(%p): semi-stub\n", iface, id );
 500
 501     if (!This->data_key)
 502         return SPERR_UNINITIALIZED;
 503
 504     if (!id)
 505         return E_POINTER;
 506
 507     /* todo: check HKCU's DefaultTokenId before */
 508
 509     this_data_key = impl_from_ISpRegDataKey( This->data_key );
 510
 511     res = RegGetValueW( this_data_key->key, NULL, L"DefaultDefaultTokenId", RRF_RT_REG_SZ,
 512                         NULL, &regvalue, &regvalue_size);
 513     if (res == ERROR_FILE_NOT_FOUND) {
 514         return SPERR_NOT_FOUND;
 515     } else if (res != ERROR_SUCCESS) {
 516         /* probably not the correct return value */
 517         FIXME( "returning %08lx\n", res );
 518         return res;
 519     }
 520
 521     *id = CoTaskMemAlloc( regvalue_size );
 522     wcscpy( *id, regvalue );
 523
 524     return S_OK;
 525 }
 526
 527 const struct ISpObjectTokenCategoryVtbl token_category_vtbl =
 528 {
 529     token_category_QueryInterface,
 530     token_category_AddRef,
 531     token_category_Release,
 532     token_category_SetData,
 533     token_category_GetData,
 534     token_category_SetStringValue,
 535     token_category_GetStringValue,
 536     token_category_SetDWORD,
 537     token_category_GetDWORD,
 538     token_category_OpenKey,
 539     token_category_CreateKey,
 540     token_category_DeleteKey,
 541     token_category_DeleteValue,
 542     token_category_EnumKeys,
 543     token_category_EnumValues,
 544     token_category_SetId,
 545     token_category_GetId,
 546     token_category_GetDataKey,
 547     token_category_EnumTokens,
 548     token_category_SetDefaultTokenId,
 549     token_category_GetDefaultTokenId,
 550 };
 551
 552 HRESULT token_category_create( IUnknown *outer, REFIID iid, void **obj )
 553 {
 554     struct token_category *This = heap_alloc( sizeof(*This) );
 555     HRESULT hr;
 556
 557     if (!This) return E_OUTOFMEMORY;
 558     This->ISpObjectTokenCategory_iface.lpVtbl = &token_category_vtbl;
 559     This->ref = 1;
 560     This->data_key = NULL;
 561
 562     hr = ISpObjectTokenCategory_QueryInterface( &This->ISpObjectTokenCategory_iface, iid, obj );
 563
 564     ISpObjectTokenCategory_Release( &This->ISpObjectTokenCategory_iface );
 565     return hr;
 566 }
 567
 568 struct token_enum
 569 {
 570     ISpObjectTokenEnumBuilder ISpObjectTokenEnumBuilder_iface;
 571     LONG ref;
 572
 573     BOOL init;
 574     WCHAR *req, *opt;
 575     ULONG count;
 576 };
 577
 578 static struct token_enum *impl_from_ISpObjectTokenEnumBuilder( ISpObjectTokenEnumBuilder *iface )
 579 {
 580     return CONTAINING_RECORD( iface, struct token_enum, ISpObjectTokenEnumBuilder_iface );
 581 }
 582
 583 static HRESULT WINAPI token_enum_QueryInterface( ISpObjectTokenEnumBuilder *iface,
 584                                                  REFIID iid, void **obj )
 585 {
 586     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 587
 588     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 589
 590     if (IsEqualIID( iid, &IID_IUnknown ) ||
 591         IsEqualIID( iid, &IID_IEnumSpObjectTokens ) ||
 592         IsEqualIID( iid, &IID_ISpObjectTokenEnumBuilder ))
 593     {
 594         ISpObjectTokenEnumBuilder_AddRef( iface );
 595         *obj = iface;
 596         return S_OK;
 597     }
 598
 599     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 600     *obj = NULL;
 601     return E_NOINTERFACE;
 602 }
 603
 604 static ULONG WINAPI token_enum_AddRef( ISpObjectTokenEnumBuilder *iface )
 605 {
 606     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 607     ULONG ref = InterlockedIncrement( &This->ref );
 608
 609     TRACE( "(%p) ref = %lu\n", This, ref );
 610     return ref;
 611 }
 612
 613 static ULONG WINAPI token_enum_Release( ISpObjectTokenEnumBuilder *iface )
 614 {
 615     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 616     ULONG ref = InterlockedDecrement(&This->ref);
 617
 618     TRACE( "(%p) ref = %lu\n", This, ref );
 619
 620     if (!ref)
 621     {
 622         heap_free( This->req );
 623         heap_free( This->opt );
 624         heap_free( This );
 625     }
 626
 627     return ref;
 628 }
 629
 630 static HRESULT WINAPI token_enum_Next( ISpObjectTokenEnumBuilder *iface,
 631                                        ULONG num, ISpObjectToken **tokens,
 632                                        ULONG *fetched )
 633 {
 634     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 635
 636     TRACE( "(%p)->(%lu %p %p)\n", This, num, tokens, fetched );
 637
 638     if (!This->init) return SPERR_UNINITIALIZED;
 639
 640     FIXME( "semi-stub: Returning an empty enumerator\n" );
 641
 642     if (fetched) *fetched = 0;
 643     return S_FALSE;
 644 }
 645
 646 static HRESULT WINAPI token_enum_Skip( ISpObjectTokenEnumBuilder *iface,
 647                                        ULONG num )
 648 {
 649     FIXME( "stub\n" );
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI token_enum_Reset( ISpObjectTokenEnumBuilder *iface)
 654 {
 655     FIXME( "stub\n" );
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI token_enum_Clone( ISpObjectTokenEnumBuilder *iface,
 660                                         IEnumSpObjectTokens **clone )
 661 {
 662     FIXME( "stub\n" );
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI token_enum_Item( ISpObjectTokenEnumBuilder *iface,
 667                                        ULONG index, ISpObjectToken **token )
 668 {
 669     FIXME( "stub\n" );
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI token_enum_GetCount( ISpObjectTokenEnumBuilder *iface,
 674                                            ULONG *count )
 675 {
 676     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 677
 678     TRACE( "(%p)->(%p)\n", This, count );
 679
 680     if (!This->init) return SPERR_UNINITIALIZED;
 681
 682     *count = This->count;
 683     return S_OK;
 684 }
 685
 686 static HRESULT WINAPI token_enum_SetAttribs( ISpObjectTokenEnumBuilder *iface,
 687                                              LPCWSTR req, LPCWSTR opt)
 688 {
 689     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 690
 691     TRACE( "(%p)->(%s %s)\n", This, debugstr_w( req ), debugstr_w( opt ) );
 692
 693     if (This->init) return SPERR_ALREADY_INITIALIZED;
 694
 695     if (req)
 696     {
 697         This->req = heap_strdupW( req );
 698         if (!This->req) goto out_of_mem;
 699     }
 700
 701     if (opt)
 702     {
 703         This->opt = heap_strdupW( opt );
 704         if (!This->opt) goto out_of_mem;
 705     }
 706
 707     This->init = TRUE;
 708     return S_OK;
 709
 710 out_of_mem:
 711     heap_free( This->req );
 712     return E_OUTOFMEMORY;
 713 }
 714
 715 static HRESULT WINAPI token_enum_AddTokens( ISpObjectTokenEnumBuilder *iface,
 716                                             ULONG num, ISpObjectToken **tokens )
 717 {
 718     FIXME( "stub\n" );
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI token_enum_AddTokensFromDataKey( ISpObjectTokenEnumBuilder *iface,
 723                                                        ISpDataKey *data_key,
 724                                                        LPCWSTR sub_key, LPCWSTR cat_id )
 725 {
 726     FIXME( "stub\n" );
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI token_enum_AddTokensFromTokenEnum( ISpObjectTokenEnumBuilder *iface,
 731                                                          IEnumSpObjectTokens *token_enum )
 732 {
 733     FIXME( "stub\n" );
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI token_enum_Sort( ISpObjectTokenEnumBuilder *iface,
 738                                        LPCWSTR first )
 739 {
 740     FIXME( "stub\n" );
 741     return E_NOTIMPL;
 742 }
 743
 744 const struct ISpObjectTokenEnumBuilderVtbl token_enum_vtbl =
 745 {
 746     token_enum_QueryInterface,
 747     token_enum_AddRef,
 748     token_enum_Release,
 749     token_enum_Next,
 750     token_enum_Skip,
 751     token_enum_Reset,
 752     token_enum_Clone,
 753     token_enum_Item,
 754     token_enum_GetCount,
 755     token_enum_SetAttribs,
 756     token_enum_AddTokens,
 757     token_enum_AddTokensFromDataKey,
 758     token_enum_AddTokensFromTokenEnum,
 759     token_enum_Sort
 760 };
 761
 762 HRESULT token_enum_create( IUnknown *outer, REFIID iid, void **obj )
 763 {
 764     struct token_enum *This = heap_alloc( sizeof(*This) );
 765     HRESULT hr;
 766
 767     if (!This) return E_OUTOFMEMORY;
 768     This->ISpObjectTokenEnumBuilder_iface.lpVtbl = &token_enum_vtbl;
 769     This->ref = 1;
 770     This->req = NULL;
 771     This->opt = NULL;
 772     This->init = FALSE;
 773     This->count = 0;
 774
 775     hr = ISpObjectTokenEnumBuilder_QueryInterface( &This->ISpObjectTokenEnumBuilder_iface, iid, obj );
 776
 777     ISpObjectTokenEnumBuilder_Release( &This->ISpObjectTokenEnumBuilder_iface );
 778     return hr;
 779 }
 780
 781 struct object_token
 782 {
 783     ISpObjectToken ISpObjectToken_iface;
 784     LONG ref;
 785
 786     HKEY token_key;
 787 };
 788
 789 static struct object_token *impl_from_ISpObjectToken( ISpObjectToken *iface )
 790 {
 791     return CONTAINING_RECORD( iface, struct object_token, ISpObjectToken_iface );
 792 }
 793
 794 static HRESULT WINAPI token_QueryInterface( ISpObjectToken *iface,
 795                                             REFIID iid, void **obj )
 796 {
 797     struct object_token *This = impl_from_ISpObjectToken( iface );
 798
 799     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 800
 801     if (IsEqualIID( iid, &IID_IUnknown ) ||
 802         IsEqualIID( iid, &IID_ISpDataKey ) ||
 803         IsEqualIID( iid, &IID_ISpObjectToken ))
 804     {
 805         ISpObjectToken_AddRef( iface );
 806         *obj = iface;
 807         return S_OK;
 808     }
 809
 810     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 811     *obj = NULL;
 812     return E_NOINTERFACE;
 813 }
 814
 815 static ULONG WINAPI token_AddRef( ISpObjectToken *iface )
 816 {
 817     struct object_token *This = impl_from_ISpObjectToken( iface );
 818     ULONG ref = InterlockedIncrement( &This->ref );
 819
 820     TRACE( "(%p) ref = %lu\n", This, ref );
 821     return ref;
 822 }
 823
 824 static ULONG WINAPI token_Release( ISpObjectToken *iface )
 825 {
 826     struct object_token *This = impl_from_ISpObjectToken( iface );
 827     ULONG ref = InterlockedDecrement(&This->ref);
 828
 829     TRACE( "(%p) ref = %lu\n", This, ref );
 830
 831     if (!ref)
 832     {
 833         if (This->token_key) RegCloseKey( This->token_key );
 834         heap_free( This );
 835     }
 836
 837     return ref;
 838 }
 839
 840 static HRESULT WINAPI token_SetData( ISpObjectToken *iface,
 841                                      LPCWSTR name, ULONG size,
 842                                      const BYTE *data )
 843 {
 844     FIXME( "stub\n" );
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI token_GetData( ISpObjectToken *iface,
 849                                      LPCWSTR name, ULONG *size,
 850                                      BYTE *data )
 851 {
 852     FIXME( "stub\n" );
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI token_SetStringValue( ISpObjectToken *iface,
 857                                             LPCWSTR name, LPCWSTR value )
 858 {
 859     FIXME( "stub\n" );
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI token_GetStringValue( ISpObjectToken *iface,
 864                                             LPCWSTR name, LPWSTR *value )
 865 {
 866     FIXME( "stub\n" );
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI token_SetDWORD( ISpObjectToken *iface,
 871                                       LPCWSTR name, DWORD value )
 872 {
 873     FIXME( "stub\n" );
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI token_GetDWORD( ISpObjectToken *iface,
 878                                       LPCWSTR name, DWORD *pdwValue )
 879 {
 880     FIXME( "stub\n" );
 881     return E_NOTIMPL;
 882 }
 883
 884 static HRESULT WINAPI token_OpenKey( ISpObjectToken *iface,
 885                                      LPCWSTR name, ISpDataKey **sub_key )
 886 {
 887     FIXME( "stub\n" );
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI token_CreateKey( ISpObjectToken *iface,
 892                                        LPCWSTR name, ISpDataKey **sub_key )
 893 {
 894     FIXME( "stub\n" );
 895     return E_NOTIMPL;
 896 }
 897
 898 static HRESULT WINAPI token_DeleteKey( ISpObjectToken *iface,
 899                                        LPCWSTR name )
 900 {
 901     FIXME( "stub\n" );
 902     return E_NOTIMPL;
 903 }
 904
 905 static HRESULT WINAPI token_DeleteValue( ISpObjectToken *iface,
 906                                          LPCWSTR name )
 907 {
 908     FIXME( "stub\n" );
 909     return E_NOTIMPL;
 910 }
 911
 912 static HRESULT WINAPI token_EnumKeys( ISpObjectToken *iface,
 913                                       ULONG index, LPWSTR *sub_key )
 914 {
 915     FIXME( "stub\n" );
 916     return E_NOTIMPL;
 917 }
 918
 919 static HRESULT WINAPI token_EnumValues( ISpObjectToken *iface,
 920                                         ULONG index, LPWSTR *value )
 921 {
 922     FIXME( "stub\n" );
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI token_SetId( ISpObjectToken *iface,
 927                                    LPCWSTR category_id, LPCWSTR token_id,
 928                                    BOOL create )
 929 {
 930     struct object_token *This = impl_from_ISpObjectToken( iface );
 931     BOOL res;
 932     HRESULT hr;
 933     HKEY root, key;
 934     const WCHAR *subkey;
 935
 936     FIXME( "(%p)->(%s %s %d): semi-stub\n", This, debugstr_w( category_id ),
 937            debugstr_w(token_id), create );
 938
 939     if (This->token_key) return SPERR_ALREADY_INITIALIZED;
 940
 941     if (!token_id) return E_POINTER;
 942
 943     hr = parse_cat_id( token_id, &root, &subkey );
 944     if (hr != S_OK) return SPERR_NOT_FOUND;
 945
 946     if (create)
 947         res = RegCreateKeyExW( root, subkey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL);
 948     else
 949         res = RegOpenKeyExW( root, subkey, 0, KEY_ALL_ACCESS, &key );
 950     if (res) return SPERR_NOT_FOUND;
 951
 952     This->token_key = key;
 953
 954     return S_OK;
 955 }
 956
 957 static HRESULT WINAPI token_GetId( ISpObjectToken *iface,
 958                                    LPWSTR *token_id )
 959 {
 960     FIXME( "stub\n" );
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI token_GetCategory( ISpObjectToken *iface,
 965                                          ISpObjectTokenCategory **category )
 966 {
 967     FIXME( "stub\n" );
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI token_CreateInstance( ISpObjectToken *iface,
 972                                             IUnknown *outer,
 973                                             DWORD class_context,
 974                                             REFIID riid,
 975                                             void **object )
 976 {
 977     FIXME( "stub\n" );
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI token_GetStorageFileName( ISpObjectToken *iface,
 982                                                 REFCLSID caller,
 983                                                 LPCWSTR key_name,
 984                                                 LPCWSTR filename,
 985                                                 ULONG folder,
 986                                                 LPWSTR *filepath )
 987 {
 988     FIXME( "stub\n" );
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI token_RemoveStorageFileName( ISpObjectToken *iface,
 993                                                    REFCLSID caller,
 994                                                    LPCWSTR key_name,
 995                                                    BOOL delete_file )
 996 {
 997     FIXME( "stub\n" );
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI token_Remove( ISpObjectToken *iface,
1002                                     REFCLSID caller )
1003 {
1004     FIXME( "stub\n" );
1005     return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI token_IsUISupported( ISpObjectToken *iface,
1009                                            LPCWSTR ui_type,
1010                                            void *extra_data,
1011                                            ULONG extra_data_size,
1012                                            IUnknown *object,
1013                                            BOOL *supported )
1014 {
1015     FIXME( "stub\n" );
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI token_DisplayUI( ISpObjectToken *iface,
1020                                        HWND parent,
1021                                        LPCWSTR title,
1022                                        LPCWSTR ui_type,
1023                                        void *extra_data,
1024                                        ULONG extra_data_size,
1025                                        IUnknown *object )
1026 {
1027     FIXME( "stub\n" );
1028     return E_NOTIMPL;
1029 }
1030
1031 static HRESULT WINAPI token_MatchesAttributes( ISpObjectToken *iface,
1032                                                LPCWSTR attributes,
1033                                                BOOL *matches )
1034 {
1035     FIXME( "stub\n" );
1036     return E_NOTIMPL;
1037 }
1038
1039 const struct ISpObjectTokenVtbl token_vtbl =
1040 {
1041     token_QueryInterface,
1042     token_AddRef,
1043     token_Release,
1044     token_SetData,
1045     token_GetData,
1046     token_SetStringValue,
1047     token_GetStringValue,
1048     token_SetDWORD,
1049     token_GetDWORD,
1050     token_OpenKey,
1051     token_CreateKey,
1052     token_DeleteKey,
1053     token_DeleteValue,
1054     token_EnumKeys,
1055     token_EnumValues,
1056     token_SetId,
1057     token_GetId,
1058     token_GetCategory,
1059     token_CreateInstance,
1060     token_GetStorageFileName,
1061     token_RemoveStorageFileName,
1062     token_Remove,
1063     token_IsUISupported,
1064     token_DisplayUI,
1065     token_MatchesAttributes
1066 };
1067
1068 HRESULT token_create( IUnknown *outer, REFIID iid, void **obj )
1069 {
1070     struct object_token *This = heap_alloc( sizeof(*This) );
1071     HRESULT hr;
1072
1073     if (!This) return E_OUTOFMEMORY;
1074     This->ISpObjectToken_iface.lpVtbl = &token_vtbl;
1075     This->ref = 1;
1076
1077     This->token_key = NULL;
1078
1079     hr = ISpObjectToken_QueryInterface( &This->ISpObjectToken_iface, iid, obj );
1080
1081     ISpObjectToken_Release( &This->ISpObjectToken_iface );
1082     return hr;
1083 }