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 = %u\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 = %u\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 = %u\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 = %u\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     static const WCHAR HKLM[] = {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E','\\'};
 376     static const WCHAR HKCU[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\'};
 377     struct table
 378     {
 379         const WCHAR *name;
 380         int size;
 381         HKEY key;
 382     } table[] =
 383     {
 384         { HKLM, sizeof(HKLM), HKEY_LOCAL_MACHINE },
 385         { HKCU, sizeof(HKCU), HKEY_CURRENT_USER },
 386         { NULL }
 387     };
 388     struct table *ptr;
 389     int len = lstrlenW( str );
 390
 391     for (ptr = table; ptr->name; ptr++)
 392     {
 393         if (len >= ptr->size / sizeof(ptr->name[0]) && !memcmp( str, ptr->name, ptr->size ))
 394         {
 395             *root = ptr->key;
 396             *sub_key = str + ptr->size / sizeof(ptr->name[0]);
 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) FIXME( "Ignoring create\n" );
 420
 421     res = RegOpenKeyExW( root, subkey, 0, KEY_ALL_ACCESS, &key );
 422     if (res) return SPERR_INVALID_REGISTRY_KEY;
 423
 424     hr = CoCreateInstance( &CLSID_SpDataKey, NULL, CLSCTX_ALL,
 425                            &IID_ISpRegDataKey, (void **)&This->data_key );
 426     if (FAILED(hr)) goto fail;
 427
 428     hr = ISpRegDataKey_SetKey( This->data_key, key, FALSE );
 429     if (FAILED(hr)) goto fail;
 430
 431     return hr;
 432
 433 fail:
 434     RegCloseKey( key );
 435     return hr;
 436 }
 437
 438 static HRESULT WINAPI token_category_GetId( ISpObjectTokenCategory *iface,
 439                                             LPWSTR *id )
 440 {
 441     FIXME( "stub\n" );
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI token_category_GetDataKey( ISpObjectTokenCategory *iface,
 446                                                  SPDATAKEYLOCATION location,
 447                                                  ISpDataKey **data_key )
 448 {
 449     FIXME( "stub\n" );
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI token_category_EnumTokens( ISpObjectTokenCategory *iface,
 454                                                  LPCWSTR req, LPCWSTR opt,
 455                                                  IEnumSpObjectTokens **enum_tokens )
 456 {
 457     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 458     ISpObjectTokenEnumBuilder *builder;
 459     HRESULT hr;
 460
 461     FIXME( "(%p)->(%s %s %p): semi-stub\n", This, debugstr_w( req ), debugstr_w( opt ), enum_tokens );
 462
 463     if (!This->data_key) return SPERR_UNINITIALIZED;
 464
 465     hr = CoCreateInstance( &CLSID_SpObjectTokenEnum, NULL, CLSCTX_ALL,
 466                            &IID_ISpObjectTokenEnumBuilder, (void **)&builder );
 467     if (FAILED(hr)) return hr;
 468
 469     hr = ISpObjectTokenEnumBuilder_SetAttribs( builder, req, opt );
 470     if (FAILED(hr)) goto fail;
 471
 472     /* FIXME: Build the enumerator */
 473
 474     hr = ISpObjectTokenEnumBuilder_QueryInterface( builder, &IID_IEnumSpObjectTokens,
 475                                                    (void **)enum_tokens );
 476
 477 fail:
 478     ISpObjectTokenEnumBuilder_Release( builder );
 479     return hr;
 480 }
 481
 482 static HRESULT WINAPI token_category_SetDefaultTokenId( ISpObjectTokenCategory *iface,
 483                                                         LPCWSTR id )
 484 {
 485     FIXME( "stub\n" );
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI token_category_GetDefaultTokenId( ISpObjectTokenCategory *iface,
 490                                                         LPWSTR *id )
 491 {
 492     FIXME( "stub\n" );
 493     return E_NOTIMPL;
 494 }
 495
 496 const struct ISpObjectTokenCategoryVtbl token_category_vtbl =
 497 {
 498     token_category_QueryInterface,
 499     token_category_AddRef,
 500     token_category_Release,
 501     token_category_SetData,
 502     token_category_GetData,
 503     token_category_SetStringValue,
 504     token_category_GetStringValue,
 505     token_category_SetDWORD,
 506     token_category_GetDWORD,
 507     token_category_OpenKey,
 508     token_category_CreateKey,
 509     token_category_DeleteKey,
 510     token_category_DeleteValue,
 511     token_category_EnumKeys,
 512     token_category_EnumValues,
 513     token_category_SetId,
 514     token_category_GetId,
 515     token_category_GetDataKey,
 516     token_category_EnumTokens,
 517     token_category_SetDefaultTokenId,
 518     token_category_GetDefaultTokenId,
 519 };
 520
 521 HRESULT token_category_create( IUnknown *outer, REFIID iid, void **obj )
 522 {
 523     struct token_category *This = heap_alloc( sizeof(*This) );
 524     HRESULT hr;
 525
 526     if (!This) return E_OUTOFMEMORY;
 527     This->ISpObjectTokenCategory_iface.lpVtbl = &token_category_vtbl;
 528     This->ref = 1;
 529     This->data_key = NULL;
 530
 531     hr = ISpObjectTokenCategory_QueryInterface( &This->ISpObjectTokenCategory_iface, iid, obj );
 532
 533     ISpObjectTokenCategory_Release( &This->ISpObjectTokenCategory_iface );
 534     return hr;
 535 }
 536
 537 struct token_enum
 538 {
 539     ISpObjectTokenEnumBuilder ISpObjectTokenEnumBuilder_iface;
 540     LONG ref;
 541
 542     BOOL init;
 543     WCHAR *req, *opt;
 544     ULONG count;
 545 };
 546
 547 static struct token_enum *impl_from_ISpObjectTokenEnumBuilder( ISpObjectTokenEnumBuilder *iface )
 548 {
 549     return CONTAINING_RECORD( iface, struct token_enum, ISpObjectTokenEnumBuilder_iface );
 550 }
 551
 552 static HRESULT WINAPI token_enum_QueryInterface( ISpObjectTokenEnumBuilder *iface,
 553                                                  REFIID iid, void **obj )
 554 {
 555     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 556
 557     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 558
 559     if (IsEqualIID( iid, &IID_IUnknown ) ||
 560         IsEqualIID( iid, &IID_IEnumSpObjectTokens ) ||
 561         IsEqualIID( iid, &IID_ISpObjectTokenEnumBuilder ))
 562     {
 563         ISpObjectTokenEnumBuilder_AddRef( iface );
 564         *obj = iface;
 565         return S_OK;
 566     }
 567
 568     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 569     *obj = NULL;
 570     return E_NOINTERFACE;
 571 }
 572
 573 static ULONG WINAPI token_enum_AddRef( ISpObjectTokenEnumBuilder *iface )
 574 {
 575     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 576     ULONG ref = InterlockedIncrement( &This->ref );
 577
 578     TRACE( "(%p) ref = %u\n", This, ref );
 579     return ref;
 580 }
 581
 582 static ULONG WINAPI token_enum_Release( ISpObjectTokenEnumBuilder *iface )
 583 {
 584     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 585     ULONG ref = InterlockedDecrement(&This->ref);
 586
 587     TRACE( "(%p) ref = %u\n", This, ref );
 588
 589     if (!ref)
 590     {
 591         heap_free( This->req );
 592         heap_free( This->opt );
 593         heap_free( This );
 594     }
 595
 596     return ref;
 597 }
 598
 599 static HRESULT WINAPI token_enum_Next( ISpObjectTokenEnumBuilder *iface,
 600                                        ULONG num, ISpObjectToken **tokens,
 601                                        ULONG *fetched )
 602 {
 603     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 604
 605     TRACE( "(%p)->(%u %p %p)\n", This, num, tokens, fetched );
 606
 607     if (!This->init) return SPERR_UNINITIALIZED;
 608
 609     FIXME( "semi-stub: Returning an empty enumerator\n" );
 610
 611     if (fetched) *fetched = 0;
 612     return S_FALSE;
 613 }
 614
 615 static HRESULT WINAPI token_enum_Skip( ISpObjectTokenEnumBuilder *iface,
 616                                        ULONG num )
 617 {
 618     FIXME( "stub\n" );
 619     return E_NOTIMPL;
 620 }
 621
 622 static HRESULT WINAPI token_enum_Reset( ISpObjectTokenEnumBuilder *iface)
 623 {
 624     FIXME( "stub\n" );
 625     return E_NOTIMPL;
 626 }
 627
 628 static HRESULT WINAPI token_enum_Clone( ISpObjectTokenEnumBuilder *iface,
 629                                         IEnumSpObjectTokens **clone )
 630 {
 631     FIXME( "stub\n" );
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI token_enum_Item( ISpObjectTokenEnumBuilder *iface,
 636                                        ULONG index, ISpObjectToken **token )
 637 {
 638     FIXME( "stub\n" );
 639     return E_NOTIMPL;
 640 }
 641
 642 static HRESULT WINAPI token_enum_GetCount( ISpObjectTokenEnumBuilder *iface,
 643                                            ULONG *count )
 644 {
 645     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 646
 647     TRACE( "(%p)->(%p)\n", This, count );
 648
 649     if (!This->init) return SPERR_UNINITIALIZED;
 650
 651     *count = This->count;
 652     return S_OK;
 653 }
 654
 655 static HRESULT WINAPI token_enum_SetAttribs( ISpObjectTokenEnumBuilder *iface,
 656                                              LPCWSTR req, LPCWSTR opt)
 657 {
 658     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 659
 660     TRACE( "(%p)->(%s %s)\n", This, debugstr_w( req ), debugstr_w( opt ) );
 661
 662     if (This->init) return SPERR_ALREADY_INITIALIZED;
 663
 664     if (req)
 665     {
 666         This->req = heap_strdupW( req );
 667         if (!This->req) goto out_of_mem;
 668     }
 669
 670     if (opt)
 671     {
 672         This->opt = heap_strdupW( opt );
 673         if (!This->opt) goto out_of_mem;
 674     }
 675
 676     This->init = TRUE;
 677     return S_OK;
 678
 679 out_of_mem:
 680     heap_free( This->req );
 681     return E_OUTOFMEMORY;
 682 }
 683
 684 static HRESULT WINAPI token_enum_AddTokens( ISpObjectTokenEnumBuilder *iface,
 685                                             ULONG num, ISpObjectToken **tokens )
 686 {
 687     FIXME( "stub\n" );
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI token_enum_AddTokensFromDataKey( ISpObjectTokenEnumBuilder *iface,
 692                                                        ISpDataKey *data_key,
 693                                                        LPCWSTR sub_key, LPCWSTR cat_id )
 694 {
 695     FIXME( "stub\n" );
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT WINAPI token_enum_AddTokensFromTokenEnum( ISpObjectTokenEnumBuilder *iface,
 700                                                          IEnumSpObjectTokens *token_enum )
 701 {
 702     FIXME( "stub\n" );
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI token_enum_Sort( ISpObjectTokenEnumBuilder *iface,
 707                                        LPCWSTR first )
 708 {
 709     FIXME( "stub\n" );
 710     return E_NOTIMPL;
 711 }
 712
 713 const struct ISpObjectTokenEnumBuilderVtbl token_enum_vtbl =
 714 {
 715     token_enum_QueryInterface,
 716     token_enum_AddRef,
 717     token_enum_Release,
 718     token_enum_Next,
 719     token_enum_Skip,
 720     token_enum_Reset,
 721     token_enum_Clone,
 722     token_enum_Item,
 723     token_enum_GetCount,
 724     token_enum_SetAttribs,
 725     token_enum_AddTokens,
 726     token_enum_AddTokensFromDataKey,
 727     token_enum_AddTokensFromTokenEnum,
 728     token_enum_Sort
 729 };
 730
 731 HRESULT token_enum_create( IUnknown *outer, REFIID iid, void **obj )
 732 {
 733     struct token_enum *This = heap_alloc( sizeof(*This) );
 734     HRESULT hr;
 735
 736     if (!This) return E_OUTOFMEMORY;
 737     This->ISpObjectTokenEnumBuilder_iface.lpVtbl = &token_enum_vtbl;
 738     This->ref = 1;
 739     This->req = NULL;
 740     This->opt = NULL;
 741     This->init = FALSE;
 742     This->count = 0;
 743
 744     hr = ISpObjectTokenEnumBuilder_QueryInterface( &This->ISpObjectTokenEnumBuilder_iface, iid, obj );
 745
 746     ISpObjectTokenEnumBuilder_Release( &This->ISpObjectTokenEnumBuilder_iface );
 747     return hr;
 748 }