dlls/hnetcfg/apps.c

   1 /*
   2  * Copyright 2009 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28 #include "netfw.h"
  29 #include "natupnp.h"
  30
  31 #include "wine/debug.h"
  32 #include "hnetcfg_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
  35
  36 typedef struct fw_app
  37 {
  38     INetFwAuthorizedApplication INetFwAuthorizedApplication_iface;
  39     LONG refs;
  40     BSTR filename;
  41 } fw_app;
  42
  43 static inline fw_app *impl_from_INetFwAuthorizedApplication( INetFwAuthorizedApplication *iface )
  44 {
  45     return CONTAINING_RECORD(iface, fw_app, INetFwAuthorizedApplication_iface);
  46 }
  47
  48 static ULONG WINAPI fw_app_AddRef(
  49     INetFwAuthorizedApplication *iface )
  50 {
  51     fw_app *fw_app = impl_from_INetFwAuthorizedApplication( iface );
  52     return InterlockedIncrement( &fw_app->refs );
  53 }
  54
  55 static ULONG WINAPI fw_app_Release(
  56     INetFwAuthorizedApplication *iface )
  57 {
  58     fw_app *fw_app = impl_from_INetFwAuthorizedApplication( iface );
  59     LONG refs = InterlockedDecrement( &fw_app->refs );
  60     if (!refs)
  61     {
  62         TRACE("destroying %p\n", fw_app);
  63         SysFreeString( fw_app->filename );
  64         free( fw_app );
  65     }
  66     return refs;
  67 }
  68
  69 static HRESULT WINAPI fw_app_QueryInterface(
  70     INetFwAuthorizedApplication *iface,
  71     REFIID riid,
  72     void **ppvObject )
  73 {
  74     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
  75
  76     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  77
  78     if ( IsEqualGUID( riid, &IID_INetFwAuthorizedApplication ) ||
  79          IsEqualGUID( riid, &IID_IDispatch ) ||
  80          IsEqualGUID( riid, &IID_IUnknown ) )
  81     {
  82         *ppvObject = iface;
  83     }
  84     else
  85     {
  86         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  87         return E_NOINTERFACE;
  88     }
  89     INetFwAuthorizedApplication_AddRef( iface );
  90     return S_OK;
  91 }
  92
  93 static HRESULT WINAPI fw_app_GetTypeInfoCount(
  94     INetFwAuthorizedApplication *iface,
  95     UINT *pctinfo )
  96 {
  97     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
  98
  99     TRACE("%p %p\n", This, pctinfo);
 100     *pctinfo = 1;
 101     return S_OK;
 102 }
 103
 104 static ITypeLib *typelib;
 105 static ITypeInfo *typeinfo[last_tid];
 106
 107 static REFIID tid_id[] =
 108 {
 109     &IID_INetFwAuthorizedApplication,
 110     &IID_INetFwAuthorizedApplications,
 111     &IID_INetFwMgr,
 112     &IID_INetFwOpenPort,
 113     &IID_INetFwOpenPorts,
 114     &IID_INetFwPolicy,
 115     &IID_INetFwPolicy2,
 116     &IID_INetFwProfile,
 117     &IID_IUPnPNAT,
 118     &IID_IStaticPortMappingCollection,
 119     &IID_IStaticPortMapping,
 120 };
 121
 122 HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
 123 {
 124     HRESULT hr;
 125
 126     if (!typelib)
 127     {
 128         ITypeLib *lib;
 129
 130         hr = LoadRegTypeLib( &LIBID_NetFwPublicTypeLib, 1, 0, LOCALE_SYSTEM_DEFAULT, &lib );
 131         if (FAILED(hr))
 132         {
 133             ERR("LoadRegTypeLib failed: %08lx\n", hr);
 134             return hr;
 135         }
 136         if (InterlockedCompareExchangePointer( (void **)&typelib, lib, NULL ))
 137             ITypeLib_Release( lib );
 138     }
 139     if (!typeinfo[tid])
 140     {
 141         ITypeInfo *info;
 142
 143         hr = ITypeLib_GetTypeInfoOfGuid( typelib, tid_id[tid], &info );
 144         if (FAILED(hr))
 145         {
 146             ERR("GetTypeInfoOfGuid(%s) failed: %08lx\n", debugstr_guid(tid_id[tid]), hr);
 147             return hr;
 148         }
 149         if (InterlockedCompareExchangePointer( (void **)(typeinfo + tid), info, NULL ))
 150             ITypeInfo_Release( info );
 151     }
 152     *ret = typeinfo[tid];
 153     ITypeInfo_AddRef(typeinfo[tid]);
 154     return S_OK;
 155 }
 156
 157 void release_typelib(void)
 158 {
 159     unsigned i;
 160
 161     for (i = 0; i < ARRAY_SIZE(typeinfo); i++)
 162         if (typeinfo[i])
 163             ITypeInfo_Release(typeinfo[i]);
 164
 165     if (typelib)
 166         ITypeLib_Release(typelib);
 167 }
 168
 169 static HRESULT WINAPI fw_app_GetTypeInfo(
 170     INetFwAuthorizedApplication *iface,
 171     UINT iTInfo,
 172     LCID lcid,
 173     ITypeInfo **ppTInfo )
 174 {
 175     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 176
 177     TRACE("%p %u %lu %p\n", This, iTInfo, lcid, ppTInfo);
 178     return get_typeinfo( INetFwAuthorizedApplication_tid, ppTInfo );
 179 }
 180
 181 static HRESULT WINAPI fw_app_GetIDsOfNames(
 182     INetFwAuthorizedApplication *iface,
 183     REFIID riid,
 184     LPOLESTR *rgszNames,
 185     UINT cNames,
 186     LCID lcid,
 187     DISPID *rgDispId )
 188 {
 189     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 190     ITypeInfo *typeinfo;
 191     HRESULT hr;
 192
 193     TRACE("%p %s %p %u %lu %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 194
 195     hr = get_typeinfo( INetFwAuthorizedApplication_tid, &typeinfo );
 196     if (SUCCEEDED(hr))
 197     {
 198         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 199         ITypeInfo_Release( typeinfo );
 200     }
 201     return hr;
 202 }
 203
 204 static HRESULT WINAPI fw_app_Invoke(
 205     INetFwAuthorizedApplication *iface,
 206     DISPID dispIdMember,
 207     REFIID riid,
 208     LCID lcid,
 209     WORD wFlags,
 210     DISPPARAMS *pDispParams,
 211     VARIANT *pVarResult,
 212     EXCEPINFO *pExcepInfo,
 213     UINT *puArgErr )
 214 {
 215     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 216     ITypeInfo *typeinfo;
 217     HRESULT hr;
 218
 219     TRACE("%p %ld %s %ld %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 220           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 221
 222     hr = get_typeinfo( INetFwAuthorizedApplication_tid, &typeinfo );
 223     if (SUCCEEDED(hr))
 224     {
 225         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwAuthorizedApplication_iface, dispIdMember,
 226                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 227         ITypeInfo_Release( typeinfo );
 228     }
 229     return hr;
 230 }
 231
 232 static HRESULT WINAPI fw_app_get_Name(
 233     INetFwAuthorizedApplication *iface,
 234     BSTR *name )
 235 {
 236     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 237
 238     FIXME("%p, %p\n", This, name);
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI fw_app_put_Name(
 243     INetFwAuthorizedApplication *iface,
 244     BSTR name )
 245 {
 246     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 247
 248     FIXME("%p, %s\n", This, debugstr_w(name));
 249     return S_OK;
 250 }
 251
 252 static HRESULT WINAPI fw_app_get_ProcessImageFileName(
 253     INetFwAuthorizedApplication *iface,
 254     BSTR *imageFileName )
 255 {
 256     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 257
 258     FIXME("%p, %p\n", This, imageFileName);
 259
 260     if (!imageFileName)
 261         return E_POINTER;
 262
 263     *imageFileName = SysAllocString( This->filename );
 264     return *imageFileName || !This->filename ? S_OK : E_OUTOFMEMORY;
 265 }
 266
 267 static HRESULT WINAPI fw_app_put_ProcessImageFileName(
 268     INetFwAuthorizedApplication *iface, BSTR image )
 269 {
 270     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 271     UNIVERSAL_NAME_INFOW *info;
 272     DWORD sz, longsz;
 273     WCHAR *path, *new_path;
 274     DWORD res;
 275
 276     FIXME("%p, %s\n", This, debugstr_w(image));
 277
 278     if (!image || !image[0])
 279         return E_INVALIDARG;
 280
 281     sz = 0;
 282     res = WNetGetUniversalNameW(image, UNIVERSAL_NAME_INFO_LEVEL, NULL, &sz);
 283     if (res == WN_MORE_DATA)
 284     {
 285         if (!(path = malloc(sz)))
 286             return E_OUTOFMEMORY;
 287
 288         info = (UNIVERSAL_NAME_INFOW *)&path;
 289         res = WNetGetUniversalNameW(image, UNIVERSAL_NAME_INFO_LEVEL, &info, &sz);
 290         if (res == NO_ERROR)
 291         {
 292             SysFreeString(This->filename);
 293             This->filename = SysAllocString(info->lpUniversalName);
 294         }
 295         free(path);
 296         return HRESULT_FROM_WIN32(res);
 297     }
 298
 299     sz = GetFullPathNameW(image, 0, NULL, NULL);
 300     if (!(path = malloc(++sz * sizeof(WCHAR))))
 301         return E_OUTOFMEMORY;
 302     GetFullPathNameW(image, sz, path, NULL);
 303
 304     longsz = GetLongPathNameW(path, path, sz);
 305     if (longsz > sz)
 306     {
 307         if (!(new_path = realloc(path, longsz * sizeof(WCHAR))))
 308         {
 309             free(path);
 310             return E_OUTOFMEMORY;
 311         }
 312         path = new_path;
 313         GetLongPathNameW(path, path, longsz);
 314     }
 315
 316     SysFreeString( This->filename );
 317     This->filename = SysAllocString(path);
 318     free(path);
 319     return This->filename ? S_OK : E_OUTOFMEMORY;
 320 }
 321
 322 static HRESULT WINAPI fw_app_get_IpVersion(
 323     INetFwAuthorizedApplication *iface,
 324     NET_FW_IP_VERSION *ipVersion )
 325 {
 326     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 327
 328     TRACE("%p, %p\n", This, ipVersion);
 329
 330     if (!ipVersion)
 331         return E_POINTER;
 332     *ipVersion = NET_FW_IP_VERSION_ANY;
 333     return S_OK;
 334 }
 335
 336 static HRESULT WINAPI fw_app_put_IpVersion(
 337     INetFwAuthorizedApplication *iface,
 338     NET_FW_IP_VERSION ipVersion )
 339 {
 340     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 341
 342     TRACE("%p, %u\n", This, ipVersion);
 343     return S_OK;
 344 }
 345
 346 static HRESULT WINAPI fw_app_get_Scope(
 347     INetFwAuthorizedApplication *iface,
 348     NET_FW_SCOPE *scope )
 349 {
 350     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 351
 352     FIXME("%p, %p\n", This, scope);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI fw_app_put_Scope(
 357     INetFwAuthorizedApplication *iface,
 358     NET_FW_SCOPE scope )
 359 {
 360     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 361
 362     FIXME("%p, %u\n", This, scope);
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI fw_app_get_RemoteAddresses(
 367     INetFwAuthorizedApplication *iface,
 368     BSTR *remoteAddrs )
 369 {
 370     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 371
 372     FIXME("%p, %p\n", This, remoteAddrs);
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI fw_app_put_RemoteAddresses(
 377     INetFwAuthorizedApplication *iface,
 378     BSTR remoteAddrs )
 379 {
 380     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 381
 382     FIXME("%p, %s\n", This, debugstr_w(remoteAddrs));
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI fw_app_get_Enabled(
 387     INetFwAuthorizedApplication *iface,
 388     VARIANT_BOOL *enabled )
 389 {
 390     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 391
 392     FIXME("%p, %p\n", This, enabled);
 393
 394     *enabled = VARIANT_FALSE;
 395     return S_OK;
 396 }
 397
 398 static HRESULT WINAPI fw_app_put_Enabled(
 399     INetFwAuthorizedApplication *iface,
 400     VARIANT_BOOL enabled )
 401 {
 402     fw_app *This = impl_from_INetFwAuthorizedApplication( iface );
 403
 404     FIXME("%p, %d\n", This, enabled);
 405     return S_OK;
 406 }
 407
 408 static const struct INetFwAuthorizedApplicationVtbl fw_app_vtbl =
 409 {
 410     fw_app_QueryInterface,
 411     fw_app_AddRef,
 412     fw_app_Release,
 413     fw_app_GetTypeInfoCount,
 414     fw_app_GetTypeInfo,
 415     fw_app_GetIDsOfNames,
 416     fw_app_Invoke,
 417     fw_app_get_Name,
 418     fw_app_put_Name,
 419     fw_app_get_ProcessImageFileName,
 420     fw_app_put_ProcessImageFileName,
 421     fw_app_get_IpVersion,
 422     fw_app_put_IpVersion,
 423     fw_app_get_Scope,
 424     fw_app_put_Scope,
 425     fw_app_get_RemoteAddresses,
 426     fw_app_put_RemoteAddresses,
 427     fw_app_get_Enabled,
 428     fw_app_put_Enabled
 429 };
 430
 431 HRESULT NetFwAuthorizedApplication_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 432 {
 433     fw_app *fa;
 434
 435     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 436
 437     fa = malloc( sizeof(*fa) );
 438     if (!fa) return E_OUTOFMEMORY;
 439
 440     fa->INetFwAuthorizedApplication_iface.lpVtbl = &fw_app_vtbl;
 441     fa->refs = 1;
 442     fa->filename = NULL;
 443
 444     *ppObj = &fa->INetFwAuthorizedApplication_iface;
 445
 446     TRACE("returning iface %p\n", *ppObj);
 447     return S_OK;
 448 }
 449 typedef struct fw_apps
 450 {
 451     INetFwAuthorizedApplications INetFwAuthorizedApplications_iface;
 452     LONG refs;
 453 } fw_apps;
 454
 455 static inline fw_apps *impl_from_INetFwAuthorizedApplications( INetFwAuthorizedApplications *iface )
 456 {
 457     return CONTAINING_RECORD(iface, fw_apps, INetFwAuthorizedApplications_iface);
 458 }
 459
 460 static ULONG WINAPI fw_apps_AddRef(
 461     INetFwAuthorizedApplications *iface )
 462 {
 463     fw_apps *fw_apps = impl_from_INetFwAuthorizedApplications( iface );
 464     return InterlockedIncrement( &fw_apps->refs );
 465 }
 466
 467 static ULONG WINAPI fw_apps_Release(
 468     INetFwAuthorizedApplications *iface )
 469 {
 470     fw_apps *fw_apps = impl_from_INetFwAuthorizedApplications( iface );
 471     LONG refs = InterlockedDecrement( &fw_apps->refs );
 472     if (!refs)
 473     {
 474         TRACE("destroying %p\n", fw_apps);
 475         free( fw_apps );
 476     }
 477     return refs;
 478 }
 479
 480 static HRESULT WINAPI fw_apps_QueryInterface(
 481     INetFwAuthorizedApplications *iface,
 482     REFIID riid,
 483     void **ppvObject )
 484 {
 485     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 486
 487     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 488
 489     if ( IsEqualGUID( riid, &IID_INetFwAuthorizedApplications ) ||
 490          IsEqualGUID( riid, &IID_IDispatch ) ||
 491          IsEqualGUID( riid, &IID_IUnknown ) )
 492     {
 493         *ppvObject = iface;
 494     }
 495     else
 496     {
 497         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 498         return E_NOINTERFACE;
 499     }
 500     INetFwAuthorizedApplications_AddRef( iface );
 501     return S_OK;
 502 }
 503
 504 static HRESULT WINAPI fw_apps_GetTypeInfoCount(
 505     INetFwAuthorizedApplications *iface,
 506     UINT *pctinfo )
 507 {
 508     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 509
 510     FIXME("%p %p\n", This, pctinfo);
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI fw_apps_GetTypeInfo(
 515     INetFwAuthorizedApplications *iface,
 516     UINT iTInfo,
 517     LCID lcid,
 518     ITypeInfo **ppTInfo )
 519 {
 520     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 521
 522     TRACE("%p %u %lu %p\n", This, iTInfo, lcid, ppTInfo);
 523     return get_typeinfo( INetFwAuthorizedApplications_tid, ppTInfo );
 524 }
 525
 526 static HRESULT WINAPI fw_apps_GetIDsOfNames(
 527     INetFwAuthorizedApplications *iface,
 528     REFIID riid,
 529     LPOLESTR *rgszNames,
 530     UINT cNames,
 531     LCID lcid,
 532     DISPID *rgDispId )
 533 {
 534     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 535     ITypeInfo *typeinfo;
 536     HRESULT hr;
 537
 538     TRACE("%p %s %p %u %lu %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 539
 540     hr = get_typeinfo( INetFwAuthorizedApplications_tid, &typeinfo );
 541     if (SUCCEEDED(hr))
 542     {
 543         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 544         ITypeInfo_Release( typeinfo );
 545     }
 546     return hr;
 547 }
 548
 549 static HRESULT WINAPI fw_apps_Invoke(
 550     INetFwAuthorizedApplications *iface,
 551     DISPID dispIdMember,
 552     REFIID riid,
 553     LCID lcid,
 554     WORD wFlags,
 555     DISPPARAMS *pDispParams,
 556     VARIANT *pVarResult,
 557     EXCEPINFO *pExcepInfo,
 558     UINT *puArgErr )
 559 {
 560     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 561     ITypeInfo *typeinfo;
 562     HRESULT hr;
 563
 564     TRACE("%p %ld %s %ld %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 565           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 566
 567     hr = get_typeinfo( INetFwAuthorizedApplications_tid, &typeinfo );
 568     if (SUCCEEDED(hr))
 569     {
 570         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwAuthorizedApplications_iface, dispIdMember,
 571                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 572         ITypeInfo_Release( typeinfo );
 573     }
 574     return hr;
 575 }
 576
 577 static HRESULT WINAPI fw_apps_get_Count(
 578     INetFwAuthorizedApplications *iface,
 579     LONG *count )
 580 {
 581     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 582
 583     FIXME("%p, %p\n", This, count);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI fw_apps_Add(
 588     INetFwAuthorizedApplications *iface,
 589     INetFwAuthorizedApplication *app )
 590 {
 591     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 592
 593     FIXME("%p, %p\n", This, app);
 594     return S_OK;
 595 }
 596
 597 static HRESULT WINAPI fw_apps_Remove(
 598     INetFwAuthorizedApplications *iface,
 599     BSTR imageFileName )
 600 {
 601     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 602
 603     FIXME("%p, %s\n", This, debugstr_w(imageFileName));
 604     return S_OK;
 605 }
 606
 607 static HRESULT WINAPI fw_apps_Item(
 608     INetFwAuthorizedApplications *iface,
 609     BSTR imageFileName,
 610     INetFwAuthorizedApplication **app )
 611 {
 612     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 613
 614     TRACE("%p, %s, %p\n", This, debugstr_w(imageFileName), app);
 615     return NetFwAuthorizedApplication_create( NULL, (void **)app );
 616 }
 617
 618 static HRESULT WINAPI fw_apps_get__NewEnum(
 619     INetFwAuthorizedApplications *iface,
 620     IUnknown **newEnum )
 621 {
 622     fw_apps *This = impl_from_INetFwAuthorizedApplications( iface );
 623
 624     FIXME("%p, %p\n", This, newEnum);
 625     return E_NOTIMPL;
 626 }
 627
 628 static const struct INetFwAuthorizedApplicationsVtbl fw_apps_vtbl =
 629 {
 630     fw_apps_QueryInterface,
 631     fw_apps_AddRef,
 632     fw_apps_Release,
 633     fw_apps_GetTypeInfoCount,
 634     fw_apps_GetTypeInfo,
 635     fw_apps_GetIDsOfNames,
 636     fw_apps_Invoke,
 637     fw_apps_get_Count,
 638     fw_apps_Add,
 639     fw_apps_Remove,
 640     fw_apps_Item,
 641     fw_apps_get__NewEnum
 642 };
 643
 644 HRESULT NetFwAuthorizedApplications_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 645 {
 646     fw_apps *fa;
 647
 648     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 649
 650     fa = malloc( sizeof(*fa) );
 651     if (!fa) return E_OUTOFMEMORY;
 652
 653     fa->INetFwAuthorizedApplications_iface.lpVtbl = &fw_apps_vtbl;
 654     fa->refs = 1;
 655
 656     *ppObj = &fa->INetFwAuthorizedApplications_iface;
 657
 658     TRACE("returning iface %p\n", *ppObj);
 659     return S_OK;
 660 }