dlls/hnetcfg/port.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 "config.h"
  20 #include <stdarg.h>
  21 #include <stdio.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29 #include "netfw.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33 #include "hnetcfg_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
  36
  37 typedef struct fw_port
  38 {
  39     INetFwOpenPort INetFwOpenPort_iface;
  40     LONG refs;
  41     BSTR name;
  42     NET_FW_IP_PROTOCOL protocol;
  43     LONG port;
  44 } fw_port;
  45
  46 static inline fw_port *impl_from_INetFwOpenPort( INetFwOpenPort *iface )
  47 {
  48     return CONTAINING_RECORD(iface, fw_port, INetFwOpenPort_iface);
  49 }
  50
  51 static ULONG WINAPI fw_port_AddRef(
  52     INetFwOpenPort *iface )
  53 {
  54     fw_port *fw_port = impl_from_INetFwOpenPort( iface );
  55     return InterlockedIncrement( &fw_port->refs );
  56 }
  57
  58 static ULONG WINAPI fw_port_Release(
  59     INetFwOpenPort *iface )
  60 {
  61     fw_port *fw_port = impl_from_INetFwOpenPort( iface );
  62     LONG refs = InterlockedDecrement( &fw_port->refs );
  63     if (!refs)
  64     {
  65         TRACE("destroying %p\n", fw_port);
  66         SysFreeString( fw_port->name );
  67         HeapFree( GetProcessHeap(), 0, fw_port );
  68     }
  69     return refs;
  70 }
  71
  72 static HRESULT WINAPI fw_port_QueryInterface(
  73     INetFwOpenPort *iface,
  74     REFIID riid,
  75     void **ppvObject )
  76 {
  77     fw_port *This = impl_from_INetFwOpenPort( iface );
  78
  79     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  80
  81     if ( IsEqualGUID( riid, &IID_INetFwOpenPort ) ||
  82          IsEqualGUID( riid, &IID_IDispatch ) ||
  83          IsEqualGUID( riid, &IID_IUnknown ) )
  84     {
  85         *ppvObject = iface;
  86     }
  87     else
  88     {
  89         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  90         return E_NOINTERFACE;
  91     }
  92     INetFwOpenPort_AddRef( iface );
  93     return S_OK;
  94 }
  95
  96 static HRESULT WINAPI fw_port_GetTypeInfoCount(
  97     INetFwOpenPort *iface,
  98     UINT *pctinfo )
  99 {
 100     fw_port *This = impl_from_INetFwOpenPort( iface );
 101
 102     TRACE("%p %p\n", This, pctinfo);
 103     *pctinfo = 1;
 104     return S_OK;
 105 }
 106
 107 static HRESULT WINAPI fw_port_GetTypeInfo(
 108     INetFwOpenPort *iface,
 109     UINT iTInfo,
 110     LCID lcid,
 111     ITypeInfo **ppTInfo )
 112 {
 113     fw_port *This = impl_from_INetFwOpenPort( iface );
 114
 115     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 116     return get_typeinfo( INetFwOpenPort_tid, ppTInfo );
 117 }
 118
 119 static HRESULT WINAPI fw_port_GetIDsOfNames(
 120     INetFwOpenPort *iface,
 121     REFIID riid,
 122     LPOLESTR *rgszNames,
 123     UINT cNames,
 124     LCID lcid,
 125     DISPID *rgDispId )
 126 {
 127     fw_port *This = impl_from_INetFwOpenPort( iface );
 128     ITypeInfo *typeinfo;
 129     HRESULT hr;
 130
 131     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 132
 133     hr = get_typeinfo( INetFwOpenPort_tid, &typeinfo );
 134     if (SUCCEEDED(hr))
 135     {
 136         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 137         ITypeInfo_Release( typeinfo );
 138     }
 139     return hr;
 140 }
 141
 142 static HRESULT WINAPI fw_port_Invoke(
 143     INetFwOpenPort *iface,
 144     DISPID dispIdMember,
 145     REFIID riid,
 146     LCID lcid,
 147     WORD wFlags,
 148     DISPPARAMS *pDispParams,
 149     VARIANT *pVarResult,
 150     EXCEPINFO *pExcepInfo,
 151     UINT *puArgErr )
 152 {
 153     fw_port *This = impl_from_INetFwOpenPort( iface );
 154     ITypeInfo *typeinfo;
 155     HRESULT hr;
 156
 157     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 158           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 159
 160     hr = get_typeinfo( INetFwOpenPort_tid, &typeinfo );
 161     if (SUCCEEDED(hr))
 162     {
 163         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwOpenPort_iface, dispIdMember,
 164                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 165         ITypeInfo_Release( typeinfo );
 166     }
 167     return hr;
 168 }
 169
 170 static HRESULT WINAPI fw_port_get_Name(
 171     INetFwOpenPort *iface,
 172     BSTR *name)
 173 {
 174     fw_port *This = impl_from_INetFwOpenPort( iface );
 175
 176     FIXME("%p %p\n", This, name);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI fw_port_put_Name(
 181     INetFwOpenPort *iface,
 182     BSTR name)
 183 {
 184     fw_port *This = impl_from_INetFwOpenPort( iface );
 185
 186     TRACE("%p %s\n", This, debugstr_w(name));
 187
 188     if (!(name = SysAllocString( name )))
 189         return E_OUTOFMEMORY;
 190
 191     SysFreeString( This->name );
 192     This->name = name;
 193     return S_OK;
 194 }
 195
 196 static HRESULT WINAPI fw_port_get_IpVersion(
 197     INetFwOpenPort *iface,
 198     NET_FW_IP_VERSION *ipVersion)
 199 {
 200     fw_port *This = impl_from_INetFwOpenPort( iface );
 201
 202     FIXME("%p %p\n", This, ipVersion);
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI fw_port_put_IpVersion(
 207     INetFwOpenPort *iface,
 208     NET_FW_IP_VERSION ipVersion)
 209 {
 210     fw_port *This = impl_from_INetFwOpenPort( iface );
 211
 212     FIXME("%p %u\n", This, ipVersion);
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI fw_port_get_Protocol(
 217     INetFwOpenPort *iface,
 218     NET_FW_IP_PROTOCOL *ipProtocol)
 219 {
 220     fw_port *This = impl_from_INetFwOpenPort( iface );
 221
 222     FIXME("%p %p\n", This, ipProtocol);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI fw_port_put_Protocol(
 227     INetFwOpenPort *iface,
 228     NET_FW_IP_PROTOCOL ipProtocol)
 229 {
 230     fw_port *This = impl_from_INetFwOpenPort( iface );
 231
 232     TRACE("%p %u\n", This, ipProtocol);
 233
 234     if (ipProtocol != NET_FW_IP_PROTOCOL_TCP && ipProtocol != NET_FW_IP_PROTOCOL_UDP)
 235         return E_INVALIDARG;
 236
 237     This->protocol = ipProtocol;
 238     return S_OK;
 239 }
 240
 241 static HRESULT WINAPI fw_port_get_Port(
 242     INetFwOpenPort *iface,
 243     LONG *portNumber)
 244 {
 245     fw_port *This = impl_from_INetFwOpenPort( iface );
 246
 247     FIXME("%p %p\n", This, portNumber);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI fw_port_put_Port(
 252     INetFwOpenPort *iface,
 253     LONG portNumber)
 254 {
 255     fw_port *This = impl_from_INetFwOpenPort( iface );
 256
 257     TRACE("%p %d\n", This, portNumber);
 258     This->port = portNumber;
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI fw_port_get_Scope(
 263     INetFwOpenPort *iface,
 264     NET_FW_SCOPE *scope)
 265 {
 266     fw_port *This = impl_from_INetFwOpenPort( iface );
 267
 268     FIXME("%p %p\n", This, scope);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI fw_port_put_Scope(
 273     INetFwOpenPort *iface,
 274     NET_FW_SCOPE scope)
 275 {
 276     fw_port *This = impl_from_INetFwOpenPort( iface );
 277
 278     FIXME("%p %u\n", This, scope);
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI fw_port_get_RemoteAddresses(
 283     INetFwOpenPort *iface,
 284     BSTR *remoteAddrs)
 285 {
 286     fw_port *This = impl_from_INetFwOpenPort( iface );
 287
 288     FIXME("%p %p\n", This, remoteAddrs);
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI fw_port_put_RemoteAddresses(
 293     INetFwOpenPort *iface,
 294     BSTR remoteAddrs)
 295 {
 296     fw_port *This = impl_from_INetFwOpenPort( iface );
 297
 298     FIXME("%p %s\n", This, debugstr_w(remoteAddrs));
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI fw_port_get_Enabled(
 303     INetFwOpenPort *iface,
 304     VARIANT_BOOL *enabled)
 305 {
 306     fw_port *This = impl_from_INetFwOpenPort( iface );
 307
 308     FIXME("%p %p\n", This, enabled);
 309
 310     *enabled = VARIANT_TRUE;
 311     return S_OK;
 312 }
 313
 314 static HRESULT WINAPI fw_port_put_Enabled(
 315     INetFwOpenPort *iface,
 316     VARIANT_BOOL enabled)
 317 {
 318     fw_port *This = impl_from_INetFwOpenPort( iface );
 319
 320     FIXME("%p %d\n", This, enabled);
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI fw_port_get_BuiltIn(
 325     INetFwOpenPort *iface,
 326     VARIANT_BOOL *builtIn)
 327 {
 328     fw_port *This = impl_from_INetFwOpenPort( iface );
 329
 330     FIXME("%p %p\n", This, builtIn);
 331     return E_NOTIMPL;
 332 }
 333
 334 static const struct INetFwOpenPortVtbl fw_port_vtbl =
 335 {
 336     fw_port_QueryInterface,
 337     fw_port_AddRef,
 338     fw_port_Release,
 339     fw_port_GetTypeInfoCount,
 340     fw_port_GetTypeInfo,
 341     fw_port_GetIDsOfNames,
 342     fw_port_Invoke,
 343     fw_port_get_Name,
 344     fw_port_put_Name,
 345     fw_port_get_IpVersion,
 346     fw_port_put_IpVersion,
 347     fw_port_get_Protocol,
 348     fw_port_put_Protocol,
 349     fw_port_get_Port,
 350     fw_port_put_Port,
 351     fw_port_get_Scope,
 352     fw_port_put_Scope,
 353     fw_port_get_RemoteAddresses,
 354     fw_port_put_RemoteAddresses,
 355     fw_port_get_Enabled,
 356     fw_port_put_Enabled,
 357     fw_port_get_BuiltIn
 358 };
 359
 360 HRESULT NetFwOpenPort_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 361 {
 362     fw_port *fp;
 363
 364     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 365
 366     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 367     if (!fp) return E_OUTOFMEMORY;
 368
 369     fp->INetFwOpenPort_iface.lpVtbl = &fw_port_vtbl;
 370     fp->refs = 1;
 371     fp->name = NULL;
 372     fp->protocol = NET_FW_IP_PROTOCOL_TCP;
 373     fp->port = 0;
 374
 375     *ppObj = &fp->INetFwOpenPort_iface;
 376
 377     TRACE("returning iface %p\n", *ppObj);
 378     return S_OK;
 379 }
 380
 381 typedef struct fw_ports
 382 {
 383     INetFwOpenPorts INetFwOpenPorts_iface;
 384     LONG refs;
 385 } fw_ports;
 386
 387 static inline fw_ports *impl_from_INetFwOpenPorts( INetFwOpenPorts *iface )
 388 {
 389     return CONTAINING_RECORD(iface, fw_ports, INetFwOpenPorts_iface);
 390 }
 391
 392 static ULONG WINAPI fw_ports_AddRef(
 393     INetFwOpenPorts *iface )
 394 {
 395     fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
 396     return InterlockedIncrement( &fw_ports->refs );
 397 }
 398
 399 static ULONG WINAPI fw_ports_Release(
 400     INetFwOpenPorts *iface )
 401 {
 402     fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
 403     LONG refs = InterlockedDecrement( &fw_ports->refs );
 404     if (!refs)
 405     {
 406         TRACE("destroying %p\n", fw_ports);
 407         HeapFree( GetProcessHeap(), 0, fw_ports );
 408     }
 409     return refs;
 410 }
 411
 412 static HRESULT WINAPI fw_ports_QueryInterface(
 413     INetFwOpenPorts *iface,
 414     REFIID riid,
 415     void **ppvObject )
 416 {
 417     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 418
 419     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 420
 421     if ( IsEqualGUID( riid, &IID_INetFwOpenPorts ) ||
 422          IsEqualGUID( riid, &IID_IDispatch ) ||
 423          IsEqualGUID( riid, &IID_IUnknown ) )
 424     {
 425         *ppvObject = iface;
 426     }
 427     else
 428     {
 429         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 430         return E_NOINTERFACE;
 431     }
 432     INetFwOpenPorts_AddRef( iface );
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI fw_ports_GetTypeInfoCount(
 437     INetFwOpenPorts *iface,
 438     UINT *pctinfo )
 439 {
 440     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 441
 442     TRACE("%p %p\n", This, pctinfo);
 443     *pctinfo = 1;
 444     return S_OK;
 445 }
 446
 447 static HRESULT WINAPI fw_ports_GetTypeInfo(
 448     INetFwOpenPorts *iface,
 449     UINT iTInfo,
 450     LCID lcid,
 451     ITypeInfo **ppTInfo )
 452 {
 453     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 454
 455     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 456     return get_typeinfo( INetFwOpenPorts_tid, ppTInfo );
 457 }
 458
 459 static HRESULT WINAPI fw_ports_GetIDsOfNames(
 460     INetFwOpenPorts *iface,
 461     REFIID riid,
 462     LPOLESTR *rgszNames,
 463     UINT cNames,
 464     LCID lcid,
 465     DISPID *rgDispId )
 466 {
 467     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 468     ITypeInfo *typeinfo;
 469     HRESULT hr;
 470
 471     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 472
 473     hr = get_typeinfo( INetFwOpenPorts_tid, &typeinfo );
 474     if (SUCCEEDED(hr))
 475     {
 476         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 477         ITypeInfo_Release( typeinfo );
 478     }
 479     return hr;
 480 }
 481
 482 static HRESULT WINAPI fw_ports_Invoke(
 483     INetFwOpenPorts *iface,
 484     DISPID dispIdMember,
 485     REFIID riid,
 486     LCID lcid,
 487     WORD wFlags,
 488     DISPPARAMS *pDispParams,
 489     VARIANT *pVarResult,
 490     EXCEPINFO *pExcepInfo,
 491     UINT *puArgErr )
 492 {
 493     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 494     ITypeInfo *typeinfo;
 495     HRESULT hr;
 496
 497     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 498           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 499
 500     hr = get_typeinfo( INetFwOpenPorts_tid, &typeinfo );
 501     if (SUCCEEDED(hr))
 502     {
 503         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwOpenPorts_iface, dispIdMember,
 504                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 505         ITypeInfo_Release( typeinfo );
 506     }
 507     return hr;
 508 }
 509
 510 static HRESULT WINAPI fw_ports_get_Count(
 511     INetFwOpenPorts *iface,
 512     LONG *count)
 513 {
 514     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 515
 516     FIXME("%p, %p\n", This, count);
 517
 518     *count = 0;
 519     return S_OK;
 520 }
 521
 522 static HRESULT WINAPI fw_ports_Add(
 523     INetFwOpenPorts *iface,
 524     INetFwOpenPort *port)
 525 {
 526     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 527
 528     FIXME("%p, %p\n", This, port);
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI fw_ports_Remove(
 533     INetFwOpenPorts *iface,
 534     LONG portNumber,
 535     NET_FW_IP_PROTOCOL ipProtocol)
 536 {
 537     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 538
 539     FIXME("%p, %d, %u\n", This, portNumber, ipProtocol);
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI fw_ports_Item(
 544     INetFwOpenPorts *iface,
 545     LONG portNumber,
 546     NET_FW_IP_PROTOCOL ipProtocol,
 547     INetFwOpenPort **openPort)
 548 {
 549     HRESULT hr;
 550     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 551
 552     FIXME("%p, %d, %u, %p\n", This, portNumber, ipProtocol, openPort);
 553
 554     hr = NetFwOpenPort_create( NULL, (void **)openPort );
 555     if (SUCCEEDED(hr))
 556     {
 557         INetFwOpenPort_put_Protocol( *openPort, ipProtocol );
 558         INetFwOpenPort_put_Port( *openPort, portNumber );
 559     }
 560     return hr;
 561 }
 562
 563 static HRESULT WINAPI fw_ports_get__NewEnum(
 564     INetFwOpenPorts *iface,
 565     IUnknown **newEnum)
 566 {
 567     fw_ports *This = impl_from_INetFwOpenPorts( iface );
 568
 569     FIXME("%p, %p\n", This, newEnum);
 570     return E_NOTIMPL;
 571 }
 572
 573 static const struct INetFwOpenPortsVtbl fw_ports_vtbl =
 574 {
 575     fw_ports_QueryInterface,
 576     fw_ports_AddRef,
 577     fw_ports_Release,
 578     fw_ports_GetTypeInfoCount,
 579     fw_ports_GetTypeInfo,
 580     fw_ports_GetIDsOfNames,
 581     fw_ports_Invoke,
 582     fw_ports_get_Count,
 583     fw_ports_Add,
 584     fw_ports_Remove,
 585     fw_ports_Item,
 586     fw_ports_get__NewEnum
 587 };
 588
 589 HRESULT NetFwOpenPorts_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 590 {
 591     fw_ports *fp;
 592
 593     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 594
 595     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 596     if (!fp) return E_OUTOFMEMORY;
 597
 598     fp->INetFwOpenPorts_iface.lpVtbl = &fw_ports_vtbl;
 599     fp->refs = 1;
 600
 601     *ppObj = &fp->INetFwOpenPorts_iface;
 602
 603     TRACE("returning iface %p\n", *ppObj);
 604     return S_OK;
 605 }