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 "config.h"
  22 #include <stdarg.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     BOOL read_only;
  45 };
  46
  47 struct data_key *impl_from_ISpRegDataKey( ISpRegDataKey *iface )
  48 {
  49     return CONTAINING_RECORD( iface, struct data_key, ISpRegDataKey_iface );
  50 }
  51
  52 static HRESULT WINAPI data_key_QueryInterface( ISpRegDataKey *iface, REFIID iid, void **obj )
  53 {
  54     struct data_key *This = impl_from_ISpRegDataKey( iface );
  55
  56     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
  57
  58     if (IsEqualIID( iid, &IID_IUnknown ) ||
  59         IsEqualIID( iid, &IID_ISpDataKey ) ||
  60         IsEqualIID( iid, &IID_ISpRegDataKey ))
  61     {
  62         ISpRegDataKey_AddRef( iface );
  63         *obj = iface;
  64         return S_OK;
  65     }
  66
  67     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
  68     *obj = NULL;
  69     return E_NOINTERFACE;
  70 }
  71
  72 static ULONG WINAPI data_key_AddRef( ISpRegDataKey *iface )
  73 {
  74     struct data_key *This = impl_from_ISpRegDataKey( iface );
  75     ULONG ref = InterlockedIncrement( &This->ref );
  76
  77     TRACE( "(%p) ref = %u\n", This, ref );
  78     return ref;
  79 }
  80
  81 static ULONG WINAPI data_key_Release( ISpRegDataKey *iface )
  82 {
  83     struct data_key *This = impl_from_ISpRegDataKey( iface );
  84     ULONG ref = InterlockedDecrement(&This->ref);
  85
  86     TRACE( "(%p) ref = %u\n", This, ref );
  87
  88     if (!ref)
  89     {
  90         if (This->key) RegCloseKey( This->key );
  91         heap_free( This );
  92     }
  93
  94     return ref;
  95 }
  96
  97 static HRESULT WINAPI data_key_SetData( ISpRegDataKey *iface, LPCWSTR name,
  98                                         ULONG size, const BYTE *data )
  99 {
 100     FIXME( "stub\n" );
 101     return E_NOTIMPL;
 102 }
 103
 104 static HRESULT WINAPI data_key_GetData( ISpRegDataKey *iface, LPCWSTR name,
 105                                         ULONG *size, BYTE *data )
 106 {
 107     FIXME( "stub\n" );
 108     return E_NOTIMPL;
 109 }
 110
 111 static HRESULT WINAPI data_key_SetStringValue( ISpRegDataKey *iface,
 112                                                LPCWSTR name, LPCWSTR value )
 113 {
 114     FIXME( "stub\n" );
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI data_key_GetStringValue( ISpRegDataKey *iface,
 119                                                LPCWSTR name, LPWSTR *value )
 120 {
 121     FIXME( "stub\n" );
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI data_key_SetDWORD( ISpRegDataKey *iface,
 126                                          LPCWSTR name, DWORD value )
 127 {
 128     FIXME( "stub\n" );
 129     return E_NOTIMPL;
 130 }
 131
 132 static HRESULT WINAPI data_key_GetDWORD( ISpRegDataKey *iface,
 133                                          LPCWSTR name, DWORD *pdwValue )
 134 {
 135     FIXME( "stub\n" );
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI data_key_OpenKey( ISpRegDataKey *iface,
 140                                         LPCWSTR name, ISpDataKey **sub_key )
 141 {
 142     FIXME( "stub\n" );
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI data_key_CreateKey( ISpRegDataKey *iface,
 147                                           LPCWSTR name, ISpDataKey **sub_key )
 148 {
 149     FIXME( "stub\n" );
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI data_key_DeleteKey( ISpRegDataKey *iface, LPCWSTR name )
 154 {
 155     FIXME( "stub\n" );
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI data_key_DeleteValue( ISpRegDataKey *iface, LPCWSTR name )
 160 {
 161     FIXME( "stub\n" );
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI data_key_EnumKeys( ISpRegDataKey *iface,
 166                                          ULONG index, LPWSTR *sub_key )
 167 {
 168     FIXME( "stub\n" );
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI data_key_EnumValues( ISpRegDataKey *iface,
 173                                            ULONG index, LPWSTR *value )
 174 {
 175     FIXME( "stub\n" );
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI data_key_SetKey( ISpRegDataKey *iface,
 180                                        HKEY key, BOOL read_only )
 181 {
 182     struct data_key *This = impl_from_ISpRegDataKey( iface );
 183
 184     TRACE( "(%p)->(%p %d)\n", This, key, read_only );
 185
 186     if (This->key) return SPERR_ALREADY_INITIALIZED;
 187
 188     This->key = key;
 189     This->read_only = read_only;
 190     return S_OK;
 191 }
 192
 193 const struct ISpRegDataKeyVtbl data_key_vtbl =
 194 {
 195     data_key_QueryInterface,
 196     data_key_AddRef,
 197     data_key_Release,
 198     data_key_SetData,
 199     data_key_GetData,
 200     data_key_SetStringValue,
 201     data_key_GetStringValue,
 202     data_key_SetDWORD,
 203     data_key_GetDWORD,
 204     data_key_OpenKey,
 205     data_key_CreateKey,
 206     data_key_DeleteKey,
 207     data_key_DeleteValue,
 208     data_key_EnumKeys,
 209     data_key_EnumValues,
 210     data_key_SetKey
 211 };
 212
 213 HRESULT data_key_create( IUnknown *outer, REFIID iid, void **obj )
 214 {
 215     struct data_key *This = heap_alloc( sizeof(*This) );
 216     HRESULT hr;
 217
 218     if (!This) return E_OUTOFMEMORY;
 219     This->ISpRegDataKey_iface.lpVtbl = &data_key_vtbl;
 220     This->ref = 1;
 221     This->key = NULL;
 222     This->read_only = FALSE;
 223
 224     hr = ISpRegDataKey_QueryInterface( &This->ISpRegDataKey_iface, iid, obj );
 225
 226     ISpRegDataKey_Release( &This->ISpRegDataKey_iface );
 227     return hr;
 228 }
 229
 230 struct token_category
 231 {
 232     ISpObjectTokenCategory ISpObjectTokenCategory_iface;
 233     LONG ref;
 234
 235     ISpRegDataKey *data_key;
 236 };
 237
 238 struct token_category *impl_from_ISpObjectTokenCategory( ISpObjectTokenCategory *iface )
 239 {
 240     return CONTAINING_RECORD( iface, struct token_category, ISpObjectTokenCategory_iface );
 241 }
 242
 243 static HRESULT WINAPI token_category_QueryInterface( ISpObjectTokenCategory *iface,
 244                                                      REFIID iid, void **obj )
 245 {
 246     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 247
 248     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 249
 250     if (IsEqualIID( iid, &IID_IUnknown ) ||
 251         IsEqualIID( iid, &IID_ISpDataKey ) ||
 252         IsEqualIID( iid, &IID_ISpObjectTokenCategory ))
 253     {
 254         ISpObjectTokenCategory_AddRef( iface );
 255         *obj = iface;
 256         return S_OK;
 257     }
 258
 259     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 260     *obj = NULL;
 261     return E_NOINTERFACE;
 262 }
 263
 264 static ULONG WINAPI token_category_AddRef( ISpObjectTokenCategory *iface )
 265 {
 266     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 267     ULONG ref = InterlockedIncrement( &This->ref );
 268
 269     TRACE( "(%p) ref = %u\n", This, ref );
 270     return ref;
 271 }
 272
 273 static ULONG WINAPI token_category_Release( ISpObjectTokenCategory *iface )
 274 {
 275     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 276     ULONG ref = InterlockedDecrement(&This->ref);
 277
 278     TRACE( "(%p) ref = %u\n", This, ref );
 279
 280     if (!ref)
 281     {
 282         if (This->data_key) ISpRegDataKey_Release( This->data_key );
 283         heap_free( This );
 284     }
 285     return ref;
 286 }
 287
 288 static HRESULT WINAPI token_category_SetData( ISpObjectTokenCategory *iface,
 289                                               LPCWSTR name, ULONG size,
 290                                               const BYTE *data )
 291 {
 292     FIXME( "stub\n" );
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI token_category_GetData( ISpObjectTokenCategory *iface,
 297                                               LPCWSTR name, ULONG *size,
 298                                               BYTE *data )
 299 {
 300     FIXME( "stub\n" );
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI token_category_SetStringValue( ISpObjectTokenCategory *iface,
 305                                                      LPCWSTR name, LPCWSTR value )
 306 {
 307     FIXME( "stub\n" );
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI token_category_GetStringValue( ISpObjectTokenCategory *iface,
 312                                                      LPCWSTR name, LPWSTR *value )
 313 {
 314     FIXME( "stub\n" );
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI token_category_SetDWORD( ISpObjectTokenCategory *iface,
 319                                                LPCWSTR name, DWORD value )
 320 {
 321     FIXME( "stub\n" );
 322     return E_NOTIMPL;
 323 }
 324
 325 static HRESULT WINAPI token_category_GetDWORD( ISpObjectTokenCategory *iface,
 326                                                LPCWSTR name, DWORD *pdwValue )
 327 {
 328     FIXME( "stub\n" );
 329     return E_NOTIMPL;
 330 }
 331
 332 static HRESULT WINAPI token_category_OpenKey( ISpObjectTokenCategory *iface,
 333                                               LPCWSTR name, ISpDataKey **sub_key )
 334 {
 335     FIXME( "stub\n" );
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI token_category_CreateKey( ISpObjectTokenCategory *iface,
 340                                                 LPCWSTR name, ISpDataKey **sub_key )
 341 {
 342     FIXME( "stub\n" );
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI token_category_DeleteKey( ISpObjectTokenCategory *iface,
 347                                                 LPCWSTR name )
 348 {
 349     FIXME( "stub\n" );
 350     return E_NOTIMPL;
 351 }
 352
 353 static HRESULT WINAPI token_category_DeleteValue( ISpObjectTokenCategory *iface,
 354                                                   LPCWSTR name )
 355 {
 356     FIXME( "stub\n" );
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI token_category_EnumKeys( ISpObjectTokenCategory *iface,
 361                                                ULONG index, LPWSTR *sub_key )
 362 {
 363     FIXME( "stub\n" );
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI token_category_EnumValues( ISpObjectTokenCategory *iface,
 368                                                  ULONG index, LPWSTR *value )
 369 {
 370     FIXME( "stub\n" );
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT parse_cat_id( const WCHAR *str, HKEY *root, const WCHAR **sub_key )
 375 {
 376     static const WCHAR HKLM[] = {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E','\\'};
 377     static const WCHAR HKCU[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\'};
 378     struct table
 379     {
 380         const WCHAR *name;
 381         int size;
 382         HKEY key;
 383     } table[] =
 384     {
 385         { HKLM, sizeof(HKLM), HKEY_LOCAL_MACHINE },
 386         { HKCU, sizeof(HKCU), HKEY_CURRENT_USER },
 387         { NULL }
 388     };
 389     struct table *ptr;
 390     int len = strlenW( str );
 391
 392     for (ptr = table; ptr->name; ptr++)
 393     {
 394         if (len >= ptr->size / sizeof(ptr->name[0]) && !memcmp( str, ptr->name, ptr->size ))
 395         {
 396             *root = ptr->key;
 397             *sub_key = str + ptr->size / sizeof(ptr->name[0]);
 398             return S_OK;
 399         }
 400     }
 401     return S_FALSE;
 402 }
 403
 404 static HRESULT WINAPI token_category_SetId( ISpObjectTokenCategory *iface,
 405                                             LPCWSTR id, BOOL create )
 406 {
 407     struct token_category *This = impl_from_ISpObjectTokenCategory( iface );
 408     HKEY root, key;
 409     const WCHAR *subkey;
 410     LONG res;
 411     HRESULT hr;
 412
 413     TRACE( "(%p)->(%s %d)\n", This, debugstr_w( id ), create );
 414
 415     if (This->data_key) return SPERR_ALREADY_INITIALIZED;
 416
 417     hr = parse_cat_id( id, &root, &subkey );
 418     if (hr != S_OK) return SPERR_INVALID_REGISTRY_KEY;
 419
 420     if (create) FIXME( "Ignoring create\n" );
 421
 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     FIXME( "stub\n" );
 494     return E_NOTIMPL;
 495 }
 496
 497 const struct ISpObjectTokenCategoryVtbl token_category_vtbl =
 498 {
 499     token_category_QueryInterface,
 500     token_category_AddRef,
 501     token_category_Release,
 502     token_category_SetData,
 503     token_category_GetData,
 504     token_category_SetStringValue,
 505     token_category_GetStringValue,
 506     token_category_SetDWORD,
 507     token_category_GetDWORD,
 508     token_category_OpenKey,
 509     token_category_CreateKey,
 510     token_category_DeleteKey,
 511     token_category_DeleteValue,
 512     token_category_EnumKeys,
 513     token_category_EnumValues,
 514     token_category_SetId,
 515     token_category_GetId,
 516     token_category_GetDataKey,
 517     token_category_EnumTokens,
 518     token_category_SetDefaultTokenId,
 519     token_category_GetDefaultTokenId,
 520 };
 521
 522 HRESULT token_category_create( IUnknown *outer, REFIID iid, void **obj )
 523 {
 524     struct token_category *This = heap_alloc( sizeof(*This) );
 525     HRESULT hr;
 526
 527     if (!This) return E_OUTOFMEMORY;
 528     This->ISpObjectTokenCategory_iface.lpVtbl = &token_category_vtbl;
 529     This->ref = 1;
 530     This->data_key = NULL;
 531
 532     hr = ISpObjectTokenCategory_QueryInterface( &This->ISpObjectTokenCategory_iface, iid, obj );
 533
 534     ISpObjectTokenCategory_Release( &This->ISpObjectTokenCategory_iface );
 535     return hr;
 536 }
 537
 538 struct token_enum
 539 {
 540     ISpObjectTokenEnumBuilder ISpObjectTokenEnumBuilder_iface;
 541     LONG ref;
 542
 543     BOOL init;
 544     WCHAR *req, *opt;
 545     ULONG count;
 546 };
 547
 548 struct token_enum *impl_from_ISpObjectTokenEnumBuilder( ISpObjectTokenEnumBuilder *iface )
 549 {
 550     return CONTAINING_RECORD( iface, struct token_enum, ISpObjectTokenEnumBuilder_iface );
 551 }
 552
 553 static HRESULT WINAPI token_enum_QueryInterface( ISpObjectTokenEnumBuilder *iface,
 554                                                  REFIID iid, void **obj )
 555 {
 556     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 557
 558     TRACE( "(%p)->(%s %p)\n", This, debugstr_guid( iid ), obj );
 559
 560     if (IsEqualIID( iid, &IID_IUnknown ) ||
 561         IsEqualIID( iid, &IID_IEnumSpObjectTokens ) ||
 562         IsEqualIID( iid, &IID_ISpObjectTokenEnumBuilder ))
 563     {
 564         ISpObjectTokenEnumBuilder_AddRef( iface );
 565         *obj = iface;
 566         return S_OK;
 567     }
 568
 569     FIXME( "interface %s not implemented\n", debugstr_guid( iid ) );
 570     *obj = NULL;
 571     return E_NOINTERFACE;
 572 }
 573
 574 static ULONG WINAPI token_enum_AddRef( ISpObjectTokenEnumBuilder *iface )
 575 {
 576     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 577     ULONG ref = InterlockedIncrement( &This->ref );
 578
 579     TRACE( "(%p) ref = %u\n", This, ref );
 580     return ref;
 581 }
 582
 583 static ULONG WINAPI token_enum_Release( ISpObjectTokenEnumBuilder *iface )
 584 {
 585     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 586     ULONG ref = InterlockedDecrement(&This->ref);
 587
 588     TRACE( "(%p) ref = %u\n", This, ref );
 589
 590     if (!ref)
 591     {
 592         heap_free( This->req );
 593         heap_free( This->opt );
 594         heap_free( This );
 595     }
 596
 597     return ref;
 598 }
 599
 600 static HRESULT WINAPI token_enum_Next( ISpObjectTokenEnumBuilder *iface,
 601                                        ULONG num, ISpObjectToken **tokens,
 602                                        ULONG *fetched )
 603 {
 604     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 605
 606     TRACE( "(%p)->(%u %p %p)\n", This, num, tokens, fetched );
 607
 608     if (!This->init) return SPERR_UNINITIALIZED;
 609
 610     FIXME( "semi-stub: Returning an empty enumerator\n" );
 611
 612     if (fetched) *fetched = 0;
 613     return S_FALSE;
 614 }
 615
 616 static HRESULT WINAPI token_enum_Skip( ISpObjectTokenEnumBuilder *iface,
 617                                        ULONG num )
 618 {
 619     FIXME( "stub\n" );
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI token_enum_Reset( ISpObjectTokenEnumBuilder *iface)
 624 {
 625     FIXME( "stub\n" );
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI token_enum_Clone( ISpObjectTokenEnumBuilder *iface,
 630                                         IEnumSpObjectTokens **clone )
 631 {
 632     FIXME( "stub\n" );
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI token_enum_Item( ISpObjectTokenEnumBuilder *iface,
 637                                        ULONG index, ISpObjectToken **token )
 638 {
 639     FIXME( "stub\n" );
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI token_enum_GetCount( ISpObjectTokenEnumBuilder *iface,
 644                                            ULONG *count )
 645 {
 646     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 647
 648     TRACE( "(%p)->(%p)\n", This, count );
 649
 650     if (!This->init) return SPERR_UNINITIALIZED;
 651
 652     *count = This->count;
 653     return S_OK;
 654 }
 655
 656 static HRESULT WINAPI token_enum_SetAttribs( ISpObjectTokenEnumBuilder *iface,
 657                                              LPCWSTR req, LPCWSTR opt)
 658 {
 659     struct token_enum *This = impl_from_ISpObjectTokenEnumBuilder( iface );
 660
 661     TRACE( "(%p)->(%s %s)\n", This, debugstr_w( req ), debugstr_w( opt ) );
 662
 663     if (This->init) return SPERR_ALREADY_INITIALIZED;
 664
 665     if (req)
 666     {
 667         This->req = heap_strdupW( req );
 668         if (!This->req) goto out_of_mem;
 669     }
 670
 671     if (opt)
 672     {
 673         This->opt = heap_strdupW( opt );
 674         if (!This->opt) goto out_of_mem;
 675     }
 676
 677     This->init = TRUE;
 678     return S_OK;
 679
 680 out_of_mem:
 681     heap_free( This->req );
 682     return E_OUTOFMEMORY;
 683 }
 684
 685 static HRESULT WINAPI token_enum_AddTokens( ISpObjectTokenEnumBuilder *iface,
 686                                             ULONG num, ISpObjectToken **tokens )
 687 {
 688     FIXME( "stub\n" );
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI token_enum_AddTokensFromDataKey( ISpObjectTokenEnumBuilder *iface,
 693                                                        ISpDataKey *data_key,
 694                                                        LPCWSTR sub_key, LPCWSTR cat_id )
 695 {
 696     FIXME( "stub\n" );
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI token_enum_AddTokensFromTokenEnum( ISpObjectTokenEnumBuilder *iface,
 701                                                          IEnumSpObjectTokens *token_enum )
 702 {
 703     FIXME( "stub\n" );
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI token_enum_Sort( ISpObjectTokenEnumBuilder *iface,
 708                                        LPCWSTR first )
 709 {
 710     FIXME( "stub\n" );
 711     return E_NOTIMPL;
 712 }
 713
 714 const struct ISpObjectTokenEnumBuilderVtbl token_enum_vtbl =
 715 {
 716     token_enum_QueryInterface,
 717     token_enum_AddRef,
 718     token_enum_Release,
 719     token_enum_Next,
 720     token_enum_Skip,
 721     token_enum_Reset,
 722     token_enum_Clone,
 723     token_enum_Item,
 724     token_enum_GetCount,
 725     token_enum_SetAttribs,
 726     token_enum_AddTokens,
 727     token_enum_AddTokensFromDataKey,
 728     token_enum_AddTokensFromTokenEnum,
 729     token_enum_Sort
 730 };
 731
 732 HRESULT token_enum_create( IUnknown *outer, REFIID iid, void **obj )
 733 {
 734     struct token_enum *This = heap_alloc( sizeof(*This) );
 735     HRESULT hr;
 736
 737     if (!This) return E_OUTOFMEMORY;
 738     This->ISpObjectTokenEnumBuilder_iface.lpVtbl = &token_enum_vtbl;
 739     This->ref = 1;
 740     This->req = NULL;
 741     This->opt = NULL;
 742     This->init = FALSE;
 743     This->count = 0;
 744
 745     hr = ISpObjectTokenEnumBuilder_QueryInterface( &This->ISpObjectTokenEnumBuilder_iface, iid, obj );
 746
 747     ISpObjectTokenEnumBuilder_Release( &This->ISpObjectTokenEnumBuilder_iface );
 748     return hr;
 749 }