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