dlls/hnetcfg/service.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
  30 #include "wine/debug.h"
  31 #include "hnetcfg_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
  34
  35 typedef struct fw_service
  36 {
  37     INetFwService INetFwService_iface;
  38     LONG refs;
  39 } fw_service;
  40
  41 static inline fw_service *impl_from_INetFwService( INetFwService *iface )
  42 {
  43     return CONTAINING_RECORD(iface, fw_service, INetFwService_iface);
  44 }
  45
  46 static ULONG WINAPI fw_service_AddRef(
  47     INetFwService *iface )
  48 {
  49     fw_service *fw_service = impl_from_INetFwService( iface );
  50     return InterlockedIncrement( &fw_service->refs );
  51 }
  52
  53 static ULONG WINAPI fw_service_Release(
  54     INetFwService *iface )
  55 {
  56     fw_service *fw_service = impl_from_INetFwService( iface );
  57     LONG refs = InterlockedDecrement( &fw_service->refs );
  58     if (!refs)
  59     {
  60         TRACE("destroying %p\n", fw_service);
  61         HeapFree( GetProcessHeap(), 0, fw_service );
  62     }
  63     return refs;
  64 }
  65
  66 static HRESULT WINAPI fw_service_QueryInterface(
  67     INetFwService *iface,
  68     REFIID riid,
  69     void **ppvObject )
  70 {
  71     fw_service *This = impl_from_INetFwService( iface );
  72
  73     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  74
  75     if ( IsEqualGUID( riid, &IID_INetFwService ) ||
  76          IsEqualGUID( riid, &IID_IDispatch ) ||
  77          IsEqualGUID( riid, &IID_IUnknown ) )
  78     {
  79         *ppvObject = iface;
  80     }
  81     else
  82     {
  83         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  84         return E_NOINTERFACE;
  85     }
  86     INetFwService_AddRef( iface );
  87     return S_OK;
  88 }
  89
  90 static HRESULT WINAPI fw_service_GetTypeInfoCount(
  91     INetFwService *iface,
  92     UINT *pctinfo )
  93 {
  94     fw_service *This = impl_from_INetFwService( iface );
  95
  96     FIXME("%p %p\n", This, pctinfo);
  97     return E_NOTIMPL;
  98 }
  99
 100 static HRESULT WINAPI fw_service_GetTypeInfo(
 101     INetFwService *iface,
 102     UINT iTInfo,
 103     LCID lcid,
 104     ITypeInfo **ppTInfo )
 105 {
 106     fw_service *This = impl_from_INetFwService( iface );
 107
 108     FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI fw_service_GetIDsOfNames(
 113     INetFwService *iface,
 114     REFIID riid,
 115     LPOLESTR *rgszNames,
 116     UINT cNames,
 117     LCID lcid,
 118     DISPID *rgDispId )
 119 {
 120     fw_service *This = impl_from_INetFwService( iface );
 121
 122     FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT WINAPI fw_service_Invoke(
 127     INetFwService *iface,
 128     DISPID dispIdMember,
 129     REFIID riid,
 130     LCID lcid,
 131     WORD wFlags,
 132     DISPPARAMS *pDispParams,
 133     VARIANT *pVarResult,
 134     EXCEPINFO *pExcepInfo,
 135     UINT *puArgErr )
 136 {
 137     fw_service *This = impl_from_INetFwService( iface );
 138
 139     FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 140           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI fw_service_get_Name(
 145     INetFwService *iface,
 146     BSTR *name )
 147 {
 148     fw_service *This = impl_from_INetFwService( iface );
 149
 150     FIXME("%p %p\n", This, name);
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI fw_service_get_Type(
 155     INetFwService *iface,
 156     NET_FW_SERVICE_TYPE *type )
 157 {
 158     fw_service *This = impl_from_INetFwService( iface );
 159
 160     FIXME("%p %p\n", This, type);
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI fw_service_get_Customized(
 165         INetFwService *iface,
 166         VARIANT_BOOL *customized )
 167 {
 168     fw_service *This = impl_from_INetFwService( iface );
 169
 170     FIXME("%p %p\n", This, customized);
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI fw_service_get_IpVersion(
 175     INetFwService *iface,
 176     NET_FW_IP_VERSION *ipVersion )
 177 {
 178     fw_service *This = impl_from_INetFwService( iface );
 179
 180     FIXME("%p %p\n", This, ipVersion);
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI fw_service_put_IpVersion(
 185     INetFwService *iface,
 186     NET_FW_IP_VERSION ipVersion )
 187 {
 188     fw_service *This = impl_from_INetFwService( iface );
 189
 190     FIXME("%p %u\n", This, ipVersion);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI fw_service_get_Scope(
 195     INetFwService *iface,
 196     NET_FW_SCOPE *scope )
 197 {
 198     fw_service *This = impl_from_INetFwService( iface );
 199
 200     FIXME("%p %p\n", This, scope);
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI fw_service_put_Scope(
 205     INetFwService *iface,
 206     NET_FW_SCOPE scope )
 207 {
 208     fw_service *This = impl_from_INetFwService( iface );
 209
 210     FIXME("%p %u\n", This, scope);
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI fw_service_get_RemoteAddresses(
 215     INetFwService *iface,
 216     BSTR *remoteAddrs )
 217 {
 218     fw_service *This = impl_from_INetFwService( iface );
 219
 220     FIXME("%p %p\n", This, remoteAddrs);
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI fw_service_put_RemoteAddresses(
 225     INetFwService *iface,
 226     BSTR remoteAddrs )
 227 {
 228     fw_service *This = impl_from_INetFwService( iface );
 229
 230     FIXME("%p %s\n", This, debugstr_w(remoteAddrs));
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI fw_service_get_Enabled(
 235     INetFwService *iface,
 236     VARIANT_BOOL *enabled )
 237 {
 238     fw_service *This = impl_from_INetFwService( iface );
 239
 240     FIXME("%p %p\n", This, enabled);
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI fw_service_put_Enabled(
 245     INetFwService *iface,
 246     VARIANT_BOOL enabled )
 247 {
 248     fw_service *This = impl_from_INetFwService( iface );
 249
 250     FIXME("%p %d\n", This, enabled);
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI fw_service_get_GloballyOpenPorts(
 255     INetFwService *iface,
 256     INetFwOpenPorts **openPorts )
 257 {
 258     fw_service *This = impl_from_INetFwService( iface );
 259
 260     TRACE("%p %p\n", This, openPorts);
 261     return NetFwOpenPorts_create( NULL, (void **)openPorts );
 262 }
 263
 264 static const struct INetFwServiceVtbl fw_service_vtbl =
 265 {
 266     fw_service_QueryInterface,
 267     fw_service_AddRef,
 268     fw_service_Release,
 269     fw_service_GetTypeInfoCount,
 270     fw_service_GetTypeInfo,
 271     fw_service_GetIDsOfNames,
 272     fw_service_Invoke,
 273     fw_service_get_Name,
 274     fw_service_get_Type,
 275     fw_service_get_Customized,
 276     fw_service_get_IpVersion,
 277     fw_service_put_IpVersion,
 278     fw_service_get_Scope,
 279     fw_service_put_Scope,
 280     fw_service_get_RemoteAddresses,
 281     fw_service_put_RemoteAddresses,
 282     fw_service_get_Enabled,
 283     fw_service_put_Enabled,
 284     fw_service_get_GloballyOpenPorts
 285 };
 286
 287 static HRESULT NetFwService_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 288 {
 289     fw_service *fp;
 290
 291     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 292
 293     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 294     if (!fp) return E_OUTOFMEMORY;
 295
 296     fp->INetFwService_iface.lpVtbl = &fw_service_vtbl;
 297     fp->refs = 1;
 298
 299     *ppObj = &fp->INetFwService_iface;
 300
 301     TRACE("returning iface %p\n", *ppObj);
 302     return S_OK;
 303 }
 304
 305 typedef struct fw_services
 306 {
 307     INetFwServices INetFwServices_iface;
 308     LONG refs;
 309 } fw_services;
 310
 311 static inline fw_services *impl_from_INetFwServices( INetFwServices *iface )
 312 {
 313     return CONTAINING_RECORD(iface, fw_services, INetFwServices_iface);
 314 }
 315
 316 static ULONG WINAPI fw_services_AddRef(
 317     INetFwServices *iface )
 318 {
 319     fw_services *fw_services = impl_from_INetFwServices( iface );
 320     return InterlockedIncrement( &fw_services->refs );
 321 }
 322
 323 static ULONG WINAPI fw_services_Release(
 324     INetFwServices *iface )
 325 {
 326     fw_services *fw_services = impl_from_INetFwServices( iface );
 327     LONG refs = InterlockedDecrement( &fw_services->refs );
 328     if (!refs)
 329     {
 330         TRACE("destroying %p\n", fw_services);
 331         HeapFree( GetProcessHeap(), 0, fw_services );
 332     }
 333     return refs;
 334 }
 335
 336 static HRESULT WINAPI fw_services_QueryInterface(
 337     INetFwServices *iface,
 338     REFIID riid,
 339     void **ppvObject )
 340 {
 341     fw_services *This = impl_from_INetFwServices( iface );
 342
 343     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 344
 345     if ( IsEqualGUID( riid, &IID_INetFwServices ) ||
 346          IsEqualGUID( riid, &IID_IDispatch ) ||
 347          IsEqualGUID( riid, &IID_IUnknown ) )
 348     {
 349         *ppvObject = iface;
 350     }
 351     else
 352     {
 353         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 354         return E_NOINTERFACE;
 355     }
 356     INetFwServices_AddRef( iface );
 357     return S_OK;
 358 }
 359
 360 static HRESULT WINAPI fw_services_GetTypeInfoCount(
 361     INetFwServices *iface,
 362     UINT *pctinfo )
 363 {
 364     fw_services *This = impl_from_INetFwServices( iface );
 365
 366     FIXME("%p %p\n", This, pctinfo);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI fw_services_GetTypeInfo(
 371     INetFwServices *iface,
 372     UINT iTInfo,
 373     LCID lcid,
 374     ITypeInfo **ppTInfo )
 375 {
 376     fw_services *This = impl_from_INetFwServices( iface );
 377
 378     FIXME("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI fw_services_GetIDsOfNames(
 383     INetFwServices *iface,
 384     REFIID riid,
 385     LPOLESTR *rgszNames,
 386     UINT cNames,
 387     LCID lcid,
 388     DISPID *rgDispId )
 389 {
 390     fw_services *This = impl_from_INetFwServices( iface );
 391
 392     FIXME("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI fw_services_Invoke(
 397     INetFwServices *iface,
 398     DISPID dispIdMember,
 399     REFIID riid,
 400     LCID lcid,
 401     WORD wFlags,
 402     DISPPARAMS *pDispParams,
 403     VARIANT *pVarResult,
 404     EXCEPINFO *pExcepInfo,
 405     UINT *puArgErr )
 406 {
 407     fw_services *This = impl_from_INetFwServices( iface );
 408
 409     FIXME("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 410           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 411     return E_NOTIMPL;
 412 }
 413
 414 static HRESULT WINAPI fw_services_get_Count(
 415     INetFwServices *iface,
 416     LONG *count )
 417 {
 418     fw_services *This = impl_from_INetFwServices( iface );
 419
 420     FIXME("%p, %p\n", This, count);
 421
 422     *count = 0;
 423     return S_OK;
 424 }
 425
 426 static HRESULT WINAPI fw_services_Item(
 427     INetFwServices *iface,
 428     NET_FW_SERVICE_TYPE svcType,
 429     INetFwService **service )
 430 {
 431     fw_services *This = impl_from_INetFwServices( iface );
 432
 433     FIXME("%p, %u, %p\n", This, svcType, service);
 434     return NetFwService_create( NULL, (void **)service );
 435 }
 436
 437 static HRESULT WINAPI fw_services_get__NewEnum(
 438     INetFwServices *iface,
 439     IUnknown **newEnum )
 440 {
 441     fw_services *This = impl_from_INetFwServices( iface );
 442
 443     FIXME("%p, %p\n", This, newEnum);
 444     return E_NOTIMPL;
 445 }
 446
 447 static const struct INetFwServicesVtbl fw_services_vtbl =
 448 {
 449     fw_services_QueryInterface,
 450     fw_services_AddRef,
 451     fw_services_Release,
 452     fw_services_GetTypeInfoCount,
 453     fw_services_GetTypeInfo,
 454     fw_services_GetIDsOfNames,
 455     fw_services_Invoke,
 456     fw_services_get_Count,
 457     fw_services_Item,
 458     fw_services_get__NewEnum
 459 };
 460
 461 HRESULT NetFwServices_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 462 {
 463     fw_services *fp;
 464
 465     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 466
 467     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 468     if (!fp) return E_OUTOFMEMORY;
 469
 470     fp->INetFwServices_iface.lpVtbl = &fw_services_vtbl;
 471     fp->refs = 1;
 472
 473     *ppObj = &fp->INetFwServices_iface;
 474
 475     TRACE("returning iface %p\n", *ppObj);
 476     return S_OK;
 477 }