dlls/netprofm/list.c

   1 /*
   2  * Copyright 2014 Hans Leidekker for CodeWeavers
   3  * Copyright 2015 Michael Müller
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23
  24 #include "config.h"
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #define USE_WS_PREFIX
  29 #include "winsock2.h"
  30 #include "ws2ipdef.h"
  31 #include "iphlpapi.h"
  32 #include "ifdef.h"
  33 #include "netioapi.h"
  34 #include "initguid.h"
  35 #include "objbase.h"
  36 #include "ocidl.h"
  37 #include "netlistmgr.h"
  38 #include "olectl.h"
  39
  40 #include "wine/debug.h"
  41 #include "wine/list.h"
  42 #include "netprofm_private.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(netprofm);
  45
  46 static inline void* __WINE_ALLOC_SIZE(1) heap_alloc(size_t size)
  47 {
  48     return HeapAlloc(GetProcessHeap(), 0, size);
  49 }
  50
  51 static inline BOOL heap_free(void *mem)
  52 {
  53     return HeapFree(GetProcessHeap(), 0, mem);
  54 }
  55
  56 struct network
  57 {
  58     INetwork     INetwork_iface;
  59     LONG         refs;
  60     struct list  entry;
  61     GUID         id;
  62     VARIANT_BOOL connected_to_internet;
  63     VARIANT_BOOL connected;
  64 };
  65
  66 struct connection
  67 {
  68     INetworkConnection     INetworkConnection_iface;
  69     INetworkConnectionCost INetworkConnectionCost_iface;
  70     LONG                   refs;
  71     struct list            entry;
  72     GUID                   id;
  73     INetwork              *network;
  74     VARIANT_BOOL           connected_to_internet;
  75     VARIANT_BOOL           connected;
  76 };
  77
  78 struct connection_point
  79 {
  80     IConnectionPoint IConnectionPoint_iface;
  81     IConnectionPointContainer *container;
  82     IID iid;
  83     struct list sinks;
  84     DWORD cookie;
  85 };
  86
  87 struct list_manager
  88 {
  89     INetworkListManager INetworkListManager_iface;
  90     INetworkCostManager INetworkCostManager_iface;
  91     IConnectionPointContainer IConnectionPointContainer_iface;
  92     LONG                refs;
  93     struct list         networks;
  94     struct list         connections;
  95     struct connection_point list_mgr_cp;
  96     struct connection_point cost_mgr_cp;
  97     struct connection_point conn_mgr_cp;
  98 };
  99
 100 struct sink_entry
 101 {
 102     struct list entry;
 103     DWORD cookie;
 104     IUnknown *unk;
 105 };
 106
 107 static inline struct list_manager *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 108 {
 109     return CONTAINING_RECORD(iface, struct list_manager, IConnectionPointContainer_iface);
 110 }
 111
 112 static inline struct list_manager *impl_from_INetworkCostManager(
 113     INetworkCostManager *iface )
 114 {
 115     return CONTAINING_RECORD( iface, struct list_manager, INetworkCostManager_iface );
 116 }
 117
 118 static inline struct connection_point *impl_from_IConnectionPoint(
 119     IConnectionPoint *iface )
 120 {
 121     return CONTAINING_RECORD( iface, struct connection_point, IConnectionPoint_iface );
 122 }
 123
 124 static HRESULT WINAPI connection_point_QueryInterface(
 125     IConnectionPoint *iface,
 126     REFIID riid,
 127     void **obj )
 128 {
 129     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 130     TRACE( "%p, %s, %p\n", cp, debugstr_guid(riid), obj );
 131
 132     if (IsEqualGUID( riid, &IID_IConnectionPoint ) ||
 133         IsEqualGUID( riid, &IID_IUnknown ))
 134     {
 135         *obj = iface;
 136     }
 137     else
 138     {
 139         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 140         *obj = NULL;
 141         return E_NOINTERFACE;
 142     }
 143     IConnectionPoint_AddRef( iface );
 144     return S_OK;
 145 }
 146
 147 static ULONG WINAPI connection_point_AddRef(
 148     IConnectionPoint *iface )
 149 {
 150     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 151     return IConnectionPointContainer_AddRef( cp->container );
 152 }
 153
 154 static ULONG WINAPI connection_point_Release(
 155     IConnectionPoint *iface )
 156 {
 157     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 158     return IConnectionPointContainer_Release( cp->container );
 159 }
 160
 161 static HRESULT WINAPI connection_point_GetConnectionInterface(
 162     IConnectionPoint *iface,
 163     IID *iid )
 164 {
 165     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 166     TRACE( "%p, %p\n", cp, iid );
 167
 168     if (!iid)
 169         return E_POINTER;
 170
 171     memcpy( iid, &cp->iid, sizeof(*iid) );
 172     return S_OK;
 173 }
 174
 175 static HRESULT WINAPI connection_point_GetConnectionPointContainer(
 176     IConnectionPoint *iface,
 177     IConnectionPointContainer **container )
 178 {
 179     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 180     TRACE( "%p, %p\n", cp, container );
 181
 182     if (!container)
 183         return E_POINTER;
 184
 185     IConnectionPointContainer_AddRef( cp->container );
 186     *container = cp->container;
 187     return S_OK;
 188 }
 189
 190 static HRESULT WINAPI connection_point_Advise(
 191     IConnectionPoint *iface,
 192     IUnknown *sink,
 193     DWORD *cookie )
 194 {
 195     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 196     struct sink_entry *sink_entry;
 197     IUnknown *unk;
 198     HRESULT hr;
 199
 200     FIXME( "%p, %p, %p - semi-stub\n", cp, sink, cookie );
 201
 202     if (!sink || !cookie)
 203         return E_POINTER;
 204
 205     hr = IUnknown_QueryInterface( sink, &cp->iid, (void**)&unk );
 206     if (FAILED(hr))
 207     {
 208         WARN( "iface %s not implemented by sink\n", debugstr_guid(&cp->iid) );
 209         return CO_E_FAILEDTOOPENTHREADTOKEN;
 210     }
 211
 212     sink_entry = heap_alloc( sizeof(*sink_entry) );
 213     if (!sink_entry)
 214     {
 215         IUnknown_Release( unk );
 216         return E_OUTOFMEMORY;
 217     }
 218
 219     sink_entry->unk = unk;
 220     *cookie = sink_entry->cookie = ++cp->cookie;
 221     list_add_tail( &cp->sinks, &sink_entry->entry );
 222     return S_OK;
 223 }
 224
 225 static void sink_entry_release( struct sink_entry *entry )
 226 {
 227     list_remove( &entry->entry );
 228     IUnknown_Release( entry->unk );
 229     heap_free( entry );
 230 }
 231
 232 static HRESULT WINAPI connection_point_Unadvise(
 233     IConnectionPoint *iface,
 234     DWORD cookie )
 235 {
 236     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 237     struct sink_entry *iter;
 238
 239     TRACE( "%p, %d\n", cp, cookie );
 240
 241     LIST_FOR_EACH_ENTRY( iter, &cp->sinks, struct sink_entry, entry )
 242     {
 243         if (iter->cookie != cookie) continue;
 244         sink_entry_release( iter );
 245         return S_OK;
 246     }
 247
 248     WARN( "invalid cookie\n" );
 249     return OLE_E_NOCONNECTION;
 250 }
 251
 252 static HRESULT WINAPI connection_point_EnumConnections(
 253     IConnectionPoint *iface,
 254     IEnumConnections **connections )
 255 {
 256     struct connection_point *cp = impl_from_IConnectionPoint( iface );
 257     FIXME( "%p, %p - stub\n", cp, connections );
 258
 259     return E_NOTIMPL;
 260 }
 261
 262 static const IConnectionPointVtbl connection_point_vtbl =
 263 {
 264     connection_point_QueryInterface,
 265     connection_point_AddRef,
 266     connection_point_Release,
 267     connection_point_GetConnectionInterface,
 268     connection_point_GetConnectionPointContainer,
 269     connection_point_Advise,
 270     connection_point_Unadvise,
 271     connection_point_EnumConnections
 272 };
 273
 274 static void connection_point_init(
 275     struct connection_point *cp,
 276     REFIID riid,
 277     IConnectionPointContainer *container )
 278 {
 279     cp->IConnectionPoint_iface.lpVtbl = &connection_point_vtbl;
 280     cp->container = container;
 281     cp->cookie = 0;
 282     cp->iid = *riid;
 283     list_init( &cp->sinks );
 284 }
 285
 286 static void connection_point_release( struct connection_point *cp )
 287 {
 288     while (!list_empty( &cp->sinks ))
 289         sink_entry_release( LIST_ENTRY( list_head( &cp->sinks ), struct sink_entry, entry ) );
 290 }
 291
 292 static inline struct network *impl_from_INetwork(
 293     INetwork *iface )
 294 {
 295     return CONTAINING_RECORD( iface, struct network, INetwork_iface );
 296 }
 297
 298 static HRESULT WINAPI network_QueryInterface(
 299     INetwork *iface, REFIID riid, void **obj )
 300 {
 301     struct network *network = impl_from_INetwork( iface );
 302
 303     TRACE( "%p, %s, %p\n", network, debugstr_guid(riid), obj );
 304
 305     if (IsEqualIID( riid, &IID_INetwork ) ||
 306         IsEqualIID( riid, &IID_IDispatch ) ||
 307         IsEqualIID( riid, &IID_IUnknown ))
 308     {
 309         *obj = iface;
 310         INetwork_AddRef( iface );
 311         return S_OK;
 312     }
 313     else
 314     {
 315         WARN( "interface not supported %s\n", debugstr_guid(riid) );
 316         *obj = NULL;
 317         return E_NOINTERFACE;
 318     }
 319 }
 320
 321 static ULONG WINAPI network_AddRef(
 322     INetwork *iface )
 323 {
 324     struct network *network = impl_from_INetwork( iface );
 325
 326     TRACE( "%p\n", network );
 327     return InterlockedIncrement( &network->refs );
 328 }
 329
 330 static ULONG WINAPI network_Release(
 331     INetwork *iface )
 332 {
 333     struct network *network = impl_from_INetwork( iface );
 334     LONG refs;
 335
 336     TRACE( "%p\n", network );
 337
 338     if (!(refs = InterlockedDecrement( &network->refs )))
 339     {
 340         list_remove( &network->entry );
 341         heap_free( network );
 342     }
 343     return refs;
 344 }
 345
 346 static HRESULT WINAPI network_GetTypeInfoCount(
 347     INetwork *iface,
 348     UINT *count )
 349 {
 350     FIXME("\n");
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI network_GetTypeInfo(
 355     INetwork *iface,
 356     UINT index,
 357     LCID lcid,
 358     ITypeInfo **info )
 359 {
 360     FIXME("\n");
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI network_GetIDsOfNames(
 365     INetwork *iface,
 366     REFIID riid,
 367     LPOLESTR *names,
 368     UINT count,
 369     LCID lcid,
 370     DISPID *dispid )
 371 {
 372     FIXME("\n");
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI network_Invoke(
 377     INetwork *iface,
 378     DISPID member,
 379     REFIID riid,
 380     LCID lcid,
 381     WORD flags,
 382     DISPPARAMS *params,
 383     VARIANT *result,
 384     EXCEPINFO *excep_info,
 385     UINT *arg_err )
 386 {
 387     FIXME("\n");
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI network_GetName(
 392     INetwork *iface,
 393     BSTR *pszNetworkName )
 394 {
 395     FIXME( "%p, %p\n", iface, pszNetworkName );
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI network_SetName(
 400     INetwork *iface,
 401     BSTR szNetworkNewName )
 402 {
 403     FIXME( "%p, %s\n", iface, debugstr_w(szNetworkNewName) );
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI network_GetDescription(
 408     INetwork *iface,
 409     BSTR *pszDescription )
 410 {
 411     FIXME( "%p, %p\n", iface, pszDescription );
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI network_SetDescription(
 416     INetwork *iface,
 417     BSTR szDescription )
 418 {
 419     FIXME( "%p, %s\n", iface, debugstr_w(szDescription) );
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI network_GetNetworkId(
 424     INetwork *iface,
 425     GUID *pgdGuidNetworkId )
 426 {
 427     struct network *network = impl_from_INetwork( iface );
 428
 429     TRACE( "%p, %p\n", iface, pgdGuidNetworkId );
 430
 431     *pgdGuidNetworkId = network->id;
 432     return S_OK;
 433 }
 434
 435 static HRESULT WINAPI network_GetDomainType(
 436     INetwork *iface,
 437     NLM_DOMAIN_TYPE *pDomainType )
 438 {
 439     FIXME( "%p, %p\n", iface, pDomainType );
 440
 441     *pDomainType = NLM_DOMAIN_TYPE_NON_DOMAIN_NETWORK;
 442     return S_OK;
 443 }
 444
 445 static HRESULT WINAPI network_GetNetworkConnections(
 446     INetwork *iface,
 447     IEnumNetworkConnections **ppEnumNetworkConnection )
 448 {
 449     FIXME( "%p, %p\n", iface, ppEnumNetworkConnection );
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI network_GetTimeCreatedAndConnected(
 454     INetwork *iface,
 455     DWORD *pdwLowDateTimeCreated,
 456     DWORD *pdwHighDateTimeCreated,
 457     DWORD *pdwLowDateTimeConnected,
 458     DWORD *pdwHighDateTimeConnected )
 459 {
 460     FIXME( "%p, %p, %p, %p, %p\n", iface, pdwLowDateTimeCreated, pdwHighDateTimeCreated,
 461         pdwLowDateTimeConnected, pdwHighDateTimeConnected );
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI network_get_IsConnectedToInternet(
 466     INetwork *iface,
 467     VARIANT_BOOL *pbIsConnected )
 468 {
 469     struct network *network = impl_from_INetwork( iface );
 470
 471     TRACE( "%p, %p\n", iface, pbIsConnected );
 472
 473     *pbIsConnected = network->connected_to_internet;
 474     return S_OK;
 475 }
 476
 477 static HRESULT WINAPI network_get_IsConnected(
 478     INetwork *iface,
 479     VARIANT_BOOL *pbIsConnected )
 480 {
 481     struct network *network = impl_from_INetwork( iface );
 482
 483     TRACE( "%p, %p\n", iface, pbIsConnected );
 484
 485     *pbIsConnected = network->connected;
 486     return S_OK;
 487 }
 488
 489 static HRESULT WINAPI network_GetConnectivity(
 490     INetwork *iface,
 491     NLM_CONNECTIVITY *pConnectivity )
 492 {
 493     FIXME( "%p, %p\n", iface, pConnectivity );
 494
 495     *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET;
 496     return S_OK;
 497 }
 498
 499 static HRESULT WINAPI network_GetCategory(
 500     INetwork *iface,
 501     NLM_NETWORK_CATEGORY *pCategory )
 502 {
 503     FIXME( "%p, %p\n", iface, pCategory );
 504
 505     *pCategory = NLM_NETWORK_CATEGORY_PUBLIC;
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI network_SetCategory(
 510     INetwork *iface,
 511     NLM_NETWORK_CATEGORY NewCategory )
 512 {
 513     FIXME( "%p, %u\n", iface, NewCategory );
 514     return E_NOTIMPL;
 515 }
 516
 517 static const struct INetworkVtbl network_vtbl =
 518 {
 519     network_QueryInterface,
 520     network_AddRef,
 521     network_Release,
 522     network_GetTypeInfoCount,
 523     network_GetTypeInfo,
 524     network_GetIDsOfNames,
 525     network_Invoke,
 526     network_GetName,
 527     network_SetName,
 528     network_GetDescription,
 529     network_SetDescription,
 530     network_GetNetworkId,
 531     network_GetDomainType,
 532     network_GetNetworkConnections,
 533     network_GetTimeCreatedAndConnected,
 534     network_get_IsConnectedToInternet,
 535     network_get_IsConnected,
 536     network_GetConnectivity,
 537     network_GetCategory,
 538     network_SetCategory
 539 };
 540
 541 static struct network *create_network( const GUID *id )
 542 {
 543     struct network *ret;
 544
 545     if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
 546
 547     ret->INetwork_iface.lpVtbl = &network_vtbl;
 548     ret->refs                  = 1;
 549     ret->id                    = *id;
 550     ret->connected             = VARIANT_FALSE;
 551     ret->connected_to_internet = VARIANT_FALSE;
 552     list_init( &ret->entry );
 553
 554     return ret;
 555 }
 556
 557 static HRESULT WINAPI cost_manager_QueryInterface(
 558     INetworkCostManager *iface,
 559     REFIID riid,
 560     void **obj )
 561 {
 562     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
 563     return INetworkListManager_QueryInterface( &mgr->INetworkListManager_iface, riid, obj );
 564 }
 565
 566 static ULONG WINAPI cost_manager_AddRef(
 567     INetworkCostManager *iface )
 568 {
 569     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
 570     return INetworkListManager_AddRef( &mgr->INetworkListManager_iface );
 571 }
 572
 573 static ULONG WINAPI cost_manager_Release(
 574     INetworkCostManager *iface )
 575 {
 576     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
 577     return INetworkListManager_Release( &mgr->INetworkListManager_iface );
 578 }
 579
 580 static HRESULT WINAPI cost_manager_GetCost(
 581     INetworkCostManager *iface, DWORD *pCost, NLM_SOCKADDR *pDestIPAddr)
 582 {
 583     FIXME( "%p, %p, %p\n", iface, pCost, pDestIPAddr );
 584
 585     if (!pCost) return E_POINTER;
 586
 587     *pCost = NLM_CONNECTION_COST_UNRESTRICTED;
 588     return S_OK;
 589 }
 590
 591 static BOOL map_address_6to4( const SOCKADDR_IN6 *addr6, SOCKADDR_IN *addr4 )
 592 {
 593     ULONG i;
 594
 595     if (addr6->sin6_family != WS_AF_INET6) return FALSE;
 596
 597     for (i = 0; i < 5; i++)
 598         if (addr6->sin6_addr.u.Word[i]) return FALSE;
 599
 600     if (addr6->sin6_addr.u.Word[5] != 0xffff) return FALSE;
 601
 602     addr4->sin_family = WS_AF_INET;
 603     addr4->sin_port   = addr6->sin6_port;
 604     addr4->sin_addr.S_un.S_addr = addr6->sin6_addr.u.Word[6] << 16 | addr6->sin6_addr.u.Word[7];
 605     memset( &addr4->sin_zero, 0, sizeof(addr4->sin_zero) );
 606
 607     return TRUE;
 608 }
 609
 610 static HRESULT WINAPI cost_manager_GetDataPlanStatus(
 611     INetworkCostManager *iface, NLM_DATAPLAN_STATUS *pDataPlanStatus,
 612     NLM_SOCKADDR *pDestIPAddr)
 613 {
 614     DWORD ret, index;
 615     NET_LUID luid;
 616     SOCKADDR *dst = (SOCKADDR *)pDestIPAddr;
 617     SOCKADDR_IN addr4, *dst4;
 618
 619     FIXME( "%p, %p, %p\n", iface, pDataPlanStatus, pDestIPAddr );
 620
 621     if (!pDataPlanStatus) return E_POINTER;
 622
 623     if (dst && ((dst->sa_family == WS_AF_INET && (dst4 = (SOCKADDR_IN *)dst)) ||
 624                ((dst->sa_family == WS_AF_INET6 && map_address_6to4( (const SOCKADDR_IN6 *)dst, &addr4 )
 625                 && (dst4 = &addr4)))))
 626     {
 627         if ((ret = GetBestInterface( dst4->sin_addr.S_un.S_addr, &index )))
 628             return HRESULT_FROM_WIN32( ret );
 629
 630         if ((ret = ConvertInterfaceIndexToLuid( index, &luid )))
 631             return HRESULT_FROM_WIN32( ret );
 632
 633         if ((ret = ConvertInterfaceLuidToGuid( &luid, &pDataPlanStatus->InterfaceGuid )))
 634             return HRESULT_FROM_WIN32( ret );
 635     }
 636     else
 637     {
 638         FIXME( "interface guid not found\n" );
 639         memset( &pDataPlanStatus->InterfaceGuid, 0, sizeof(pDataPlanStatus->InterfaceGuid) );
 640     }
 641
 642     pDataPlanStatus->UsageData.UsageInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS;
 643     memset( &pDataPlanStatus->UsageData.LastSyncTime, 0, sizeof(pDataPlanStatus->UsageData.LastSyncTime) );
 644     pDataPlanStatus->DataLimitInMegabytes       = NLM_UNKNOWN_DATAPLAN_STATUS;
 645     pDataPlanStatus->InboundBandwidthInKbps     = NLM_UNKNOWN_DATAPLAN_STATUS;
 646     pDataPlanStatus->OutboundBandwidthInKbps    = NLM_UNKNOWN_DATAPLAN_STATUS;
 647     memset( &pDataPlanStatus->NextBillingCycle, 0, sizeof(pDataPlanStatus->NextBillingCycle) );
 648     pDataPlanStatus->MaxTransferSizeInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS;
 649     pDataPlanStatus->Reserved                   = 0;
 650
 651     return S_OK;
 652 }
 653
 654 static HRESULT WINAPI cost_manager_SetDestinationAddresses(
 655     INetworkCostManager *iface, UINT32 length, NLM_SOCKADDR *pDestIPAddrList,
 656     VARIANT_BOOL bAppend)
 657 {
 658     FIXME( "%p, %u, %p, %x\n", iface, length, pDestIPAddrList, bAppend );
 659     return E_NOTIMPL;
 660 }
 661
 662 static const INetworkCostManagerVtbl cost_manager_vtbl =
 663 {
 664     cost_manager_QueryInterface,
 665     cost_manager_AddRef,
 666     cost_manager_Release,
 667     cost_manager_GetCost,
 668     cost_manager_GetDataPlanStatus,
 669     cost_manager_SetDestinationAddresses
 670 };
 671
 672 struct networks_enum
 673 {
 674     IEnumNetworks        IEnumNetworks_iface;
 675     LONG                 refs;
 676     struct list_manager *mgr;
 677     struct list         *cursor;
 678 };
 679
 680 static inline struct networks_enum *impl_from_IEnumNetworks(
 681     IEnumNetworks *iface )
 682 {
 683     return CONTAINING_RECORD( iface, struct networks_enum, IEnumNetworks_iface );
 684 }
 685
 686 static HRESULT WINAPI networks_enum_QueryInterface(
 687     IEnumNetworks *iface, REFIID riid, void **obj )
 688 {
 689     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 690
 691     TRACE( "%p, %s, %p\n", iter, debugstr_guid(riid), obj );
 692
 693     if (IsEqualIID( riid, &IID_IEnumNetworks ) ||
 694         IsEqualIID( riid, &IID_IDispatch ) ||
 695         IsEqualIID( riid, &IID_IUnknown ))
 696     {
 697         *obj = iface;
 698         IEnumNetworks_AddRef( iface );
 699         return S_OK;
 700     }
 701     else
 702     {
 703         WARN( "interface not supported %s\n", debugstr_guid(riid) );
 704         *obj = NULL;
 705         return E_NOINTERFACE;
 706     }
 707 }
 708
 709 static ULONG WINAPI networks_enum_AddRef(
 710     IEnumNetworks *iface )
 711 {
 712     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 713
 714     TRACE( "%p\n", iter );
 715     return InterlockedIncrement( &iter->refs );
 716 }
 717
 718 static ULONG WINAPI networks_enum_Release(
 719     IEnumNetworks *iface )
 720 {
 721     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 722     LONG refs;
 723
 724     TRACE( "%p\n", iter );
 725
 726     if (!(refs = InterlockedDecrement( &iter->refs )))
 727     {
 728         INetworkListManager_Release( &iter->mgr->INetworkListManager_iface );
 729         heap_free( iter );
 730     }
 731     return refs;
 732 }
 733
 734 static HRESULT WINAPI networks_enum_GetTypeInfoCount(
 735     IEnumNetworks *iface,
 736     UINT *count )
 737 {
 738     FIXME("\n");
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI networks_enum_GetTypeInfo(
 743     IEnumNetworks *iface,
 744     UINT index,
 745     LCID lcid,
 746     ITypeInfo **info )
 747 {
 748     FIXME("\n");
 749     return E_NOTIMPL;
 750 }
 751
 752 static HRESULT WINAPI networks_enum_GetIDsOfNames(
 753     IEnumNetworks *iface,
 754     REFIID riid,
 755     LPOLESTR *names,
 756     UINT count,
 757     LCID lcid,
 758     DISPID *dispid )
 759 {
 760     FIXME("\n");
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI networks_enum_Invoke(
 765     IEnumNetworks *iface,
 766     DISPID member,
 767     REFIID riid,
 768     LCID lcid,
 769     WORD flags,
 770     DISPPARAMS *params,
 771     VARIANT *result,
 772     EXCEPINFO *excep_info,
 773     UINT *arg_err )
 774 {
 775     FIXME("\n");
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI networks_enum_get__NewEnum(
 780     IEnumNetworks *iface, IEnumVARIANT **ppEnumVar )
 781 {
 782     FIXME("\n");
 783     return E_NOTIMPL;
 784 }
 785
 786 static HRESULT WINAPI networks_enum_Next(
 787     IEnumNetworks *iface, ULONG count, INetwork **ret, ULONG *fetched )
 788 {
 789     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 790     ULONG i = 0;
 791
 792     TRACE( "%p, %u %p %p\n", iter, count, ret, fetched );
 793
 794     if (fetched) *fetched = 0;
 795     if (!count) return S_OK;
 796
 797     while (iter->cursor && i < count)
 798     {
 799         struct network *network = LIST_ENTRY( iter->cursor, struct network, entry );
 800         ret[i] = &network->INetwork_iface;
 801         INetwork_AddRef( ret[i] );
 802         iter->cursor = list_next( &iter->mgr->networks, iter->cursor );
 803         i++;
 804     }
 805     if (fetched) *fetched = i;
 806
 807     return i < count ? S_FALSE : S_OK;
 808 }
 809
 810 static HRESULT WINAPI networks_enum_Skip(
 811     IEnumNetworks *iface, ULONG count )
 812 {
 813     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 814
 815     TRACE( "%p, %u\n", iter, count);
 816
 817     if (!count) return S_OK;
 818     if (!iter->cursor) return S_FALSE;
 819
 820     while (count--)
 821     {
 822         iter->cursor = list_next( &iter->mgr->networks, iter->cursor );
 823         if (!iter->cursor) break;
 824     }
 825
 826     return count ? S_FALSE : S_OK;
 827 }
 828
 829 static HRESULT WINAPI networks_enum_Reset(
 830     IEnumNetworks *iface )
 831 {
 832     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 833
 834     TRACE( "%p\n", iter );
 835
 836     iter->cursor = list_head( &iter->mgr->networks );
 837     return S_OK;
 838 }
 839
 840 static HRESULT create_networks_enum(
 841     struct list_manager *, IEnumNetworks** );
 842
 843 static HRESULT WINAPI networks_enum_Clone(
 844     IEnumNetworks *iface, IEnumNetworks **ret )
 845 {
 846     struct networks_enum *iter = impl_from_IEnumNetworks( iface );
 847
 848     TRACE( "%p, %p\n", iter, ret );
 849     return create_networks_enum( iter->mgr, ret );
 850 }
 851
 852 static const IEnumNetworksVtbl networks_enum_vtbl =
 853 {
 854     networks_enum_QueryInterface,
 855     networks_enum_AddRef,
 856     networks_enum_Release,
 857     networks_enum_GetTypeInfoCount,
 858     networks_enum_GetTypeInfo,
 859     networks_enum_GetIDsOfNames,
 860     networks_enum_Invoke,
 861     networks_enum_get__NewEnum,
 862     networks_enum_Next,
 863     networks_enum_Skip,
 864     networks_enum_Reset,
 865     networks_enum_Clone
 866 };
 867
 868 static HRESULT create_networks_enum(
 869     struct list_manager *mgr, IEnumNetworks **ret )
 870 {
 871     struct networks_enum *iter;
 872
 873     *ret = NULL;
 874     if (!(iter = heap_alloc( sizeof(*iter) ))) return E_OUTOFMEMORY;
 875
 876     iter->IEnumNetworks_iface.lpVtbl = &networks_enum_vtbl;
 877     iter->cursor = list_head( &mgr->networks );
 878     iter->mgr    = mgr;
 879     INetworkListManager_AddRef( &mgr->INetworkListManager_iface );
 880     iter->refs   = 1;
 881
 882     *ret = &iter->IEnumNetworks_iface;
 883     return S_OK;
 884 }
 885
 886 static inline struct list_manager *impl_from_INetworkListManager(
 887     INetworkListManager *iface )
 888 {
 889     return CONTAINING_RECORD( iface, struct list_manager, INetworkListManager_iface );
 890 }
 891
 892 struct connections_enum
 893 {
 894     IEnumNetworkConnections IEnumNetworkConnections_iface;
 895     LONG                    refs;
 896     struct list_manager    *mgr;
 897     struct list            *cursor;
 898 };
 899
 900 static inline struct connections_enum *impl_from_IEnumNetworkConnections(
 901     IEnumNetworkConnections *iface )
 902 {
 903     return CONTAINING_RECORD( iface, struct connections_enum, IEnumNetworkConnections_iface );
 904 }
 905
 906 static HRESULT WINAPI connections_enum_QueryInterface(
 907     IEnumNetworkConnections *iface, REFIID riid, void **obj )
 908 {
 909     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
 910
 911     TRACE( "%p, %s, %p\n", iter, debugstr_guid(riid), obj );
 912
 913     if (IsEqualIID( riid, &IID_IEnumNetworkConnections ) ||
 914         IsEqualIID( riid, &IID_IDispatch ) ||
 915         IsEqualIID( riid, &IID_IUnknown ))
 916     {
 917         *obj = iface;
 918         IEnumNetworkConnections_AddRef( iface );
 919         return S_OK;
 920     }
 921     else
 922     {
 923         WARN( "interface not supported %s\n", debugstr_guid(riid) );
 924         *obj = NULL;
 925         return E_NOINTERFACE;
 926     }
 927 }
 928
 929 static ULONG WINAPI connections_enum_AddRef(
 930     IEnumNetworkConnections *iface )
 931 {
 932     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
 933
 934     TRACE( "%p\n", iter );
 935     return InterlockedIncrement( &iter->refs );
 936 }
 937
 938 static ULONG WINAPI connections_enum_Release(
 939     IEnumNetworkConnections *iface )
 940 {
 941     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
 942     LONG refs;
 943
 944     TRACE( "%p\n", iter );
 945
 946     if (!(refs = InterlockedDecrement( &iter->refs )))
 947     {
 948         INetworkListManager_Release( &iter->mgr->INetworkListManager_iface );
 949         heap_free( iter );
 950     }
 951     return refs;
 952 }
 953
 954 static HRESULT WINAPI connections_enum_GetTypeInfoCount(
 955     IEnumNetworkConnections *iface,
 956     UINT *count )
 957 {
 958     FIXME("\n");
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI connections_enum_GetTypeInfo(
 963     IEnumNetworkConnections *iface,
 964     UINT index,
 965     LCID lcid,
 966     ITypeInfo **info )
 967 {
 968     FIXME("\n");
 969     return E_NOTIMPL;
 970 }
 971
 972 static HRESULT WINAPI connections_enum_GetIDsOfNames(
 973     IEnumNetworkConnections *iface,
 974     REFIID riid,
 975     LPOLESTR *names,
 976     UINT count,
 977     LCID lcid,
 978     DISPID *dispid )
 979 {
 980     FIXME("\n");
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI connections_enum_Invoke(
 985     IEnumNetworkConnections *iface,
 986     DISPID member,
 987     REFIID riid,
 988     LCID lcid,
 989     WORD flags,
 990     DISPPARAMS *params,
 991     VARIANT *result,
 992     EXCEPINFO *excep_info,
 993     UINT *arg_err )
 994 {
 995     FIXME("\n");
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI connections_enum_get__NewEnum(
1000     IEnumNetworkConnections *iface, IEnumVARIANT **ppEnumVar )
1001 {
1002     FIXME("\n");
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI connections_enum_Next(
1007     IEnumNetworkConnections *iface, ULONG count, INetworkConnection **ret, ULONG *fetched )
1008 {
1009     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
1010     ULONG i = 0;
1011
1012     TRACE( "%p, %u %p %p\n", iter, count, ret, fetched );
1013
1014     if (fetched) *fetched = 0;
1015     if (!count) return S_OK;
1016
1017     while (iter->cursor && i < count)
1018     {
1019         struct connection *connection = LIST_ENTRY( iter->cursor, struct connection, entry );
1020         ret[i] = &connection->INetworkConnection_iface;
1021         INetworkConnection_AddRef( ret[i] );
1022         iter->cursor = list_next( &iter->mgr->connections, iter->cursor );
1023         i++;
1024     }
1025     if (fetched) *fetched = i;
1026
1027     return i < count ? S_FALSE : S_OK;
1028 }
1029
1030 static HRESULT WINAPI connections_enum_Skip(
1031     IEnumNetworkConnections *iface, ULONG count )
1032 {
1033     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
1034
1035     TRACE( "%p, %u\n", iter, count);
1036
1037     if (!count) return S_OK;
1038     if (!iter->cursor) return S_FALSE;
1039
1040     while (count--)
1041     {
1042         iter->cursor = list_next( &iter->mgr->connections, iter->cursor );
1043         if (!iter->cursor) break;
1044     }
1045
1046     return count ? S_FALSE : S_OK;
1047 }
1048
1049 static HRESULT WINAPI connections_enum_Reset(
1050     IEnumNetworkConnections *iface )
1051 {
1052     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
1053
1054     TRACE( "%p\n", iter );
1055
1056     iter->cursor = list_head( &iter->mgr->connections );
1057     return S_OK;
1058 }
1059
1060 static HRESULT create_connections_enum(
1061     struct list_manager *, IEnumNetworkConnections** );
1062
1063 static HRESULT WINAPI connections_enum_Clone(
1064     IEnumNetworkConnections *iface, IEnumNetworkConnections **ret )
1065 {
1066     struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface );
1067
1068     TRACE( "%p, %p\n", iter, ret );
1069     return create_connections_enum( iter->mgr, ret );
1070 }
1071
1072 static const IEnumNetworkConnectionsVtbl connections_enum_vtbl =
1073 {
1074     connections_enum_QueryInterface,
1075     connections_enum_AddRef,
1076     connections_enum_Release,
1077     connections_enum_GetTypeInfoCount,
1078     connections_enum_GetTypeInfo,
1079     connections_enum_GetIDsOfNames,
1080     connections_enum_Invoke,
1081     connections_enum_get__NewEnum,
1082     connections_enum_Next,
1083     connections_enum_Skip,
1084     connections_enum_Reset,
1085     connections_enum_Clone
1086 };
1087
1088 static HRESULT create_connections_enum(
1089     struct list_manager *mgr, IEnumNetworkConnections **ret )
1090 {
1091     struct connections_enum *iter;
1092
1093     *ret = NULL;
1094     if (!(iter = heap_alloc( sizeof(*iter) ))) return E_OUTOFMEMORY;
1095
1096     iter->IEnumNetworkConnections_iface.lpVtbl = &connections_enum_vtbl;
1097     iter->mgr         = mgr;
1098     INetworkListManager_AddRef( &mgr->INetworkListManager_iface );
1099     iter->cursor      = list_head( &iter->mgr->connections );
1100     iter->refs        = 1;
1101
1102     *ret = &iter->IEnumNetworkConnections_iface;
1103     return S_OK;
1104 }
1105
1106 static ULONG WINAPI list_manager_AddRef(
1107     INetworkListManager *iface )
1108 {
1109     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1110     return InterlockedIncrement( &mgr->refs );
1111 }
1112
1113 static ULONG WINAPI list_manager_Release(
1114     INetworkListManager *iface )
1115 {
1116     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1117     LONG refs = InterlockedDecrement( &mgr->refs );
1118     if (!refs)
1119     {
1120         struct list *ptr;
1121
1122         TRACE( "destroying %p\n", mgr );
1123
1124         connection_point_release( &mgr->conn_mgr_cp );
1125         connection_point_release( &mgr->cost_mgr_cp );
1126         connection_point_release( &mgr->list_mgr_cp );
1127         while ((ptr = list_head( &mgr->networks )))
1128         {
1129             struct network *network = LIST_ENTRY( ptr, struct network, entry );
1130             list_remove( &network->entry );
1131             INetwork_Release( &network->INetwork_iface );
1132         }
1133         while ((ptr = list_head( &mgr->connections )))
1134         {
1135             struct connection *connection = LIST_ENTRY( ptr, struct connection, entry );
1136             list_remove( &connection->entry );
1137             INetworkConnection_Release( &connection->INetworkConnection_iface );
1138         }
1139         heap_free( mgr );
1140     }
1141     return refs;
1142 }
1143
1144 static HRESULT WINAPI list_manager_QueryInterface(
1145     INetworkListManager *iface,
1146     REFIID riid,
1147     void **obj )
1148 {
1149     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1150
1151     TRACE( "%p, %s, %p\n", mgr, debugstr_guid(riid), obj );
1152
1153     if (IsEqualGUID( riid, &IID_INetworkListManager ) ||
1154         IsEqualGUID( riid, &IID_IDispatch ) ||
1155         IsEqualGUID( riid, &IID_IUnknown ))
1156     {
1157         *obj = iface;
1158     }
1159     else if (IsEqualGUID( riid, &IID_INetworkCostManager ))
1160     {
1161         *obj = &mgr->INetworkCostManager_iface;
1162     }
1163     else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
1164     {
1165         *obj = &mgr->IConnectionPointContainer_iface;
1166     }
1167     else
1168     {
1169         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1170         *obj = NULL;
1171         return E_NOINTERFACE;
1172     }
1173     INetworkListManager_AddRef( iface );
1174     return S_OK;
1175 }
1176
1177 static HRESULT WINAPI list_manager_GetTypeInfoCount(
1178     INetworkListManager *iface,
1179     UINT *count )
1180 {
1181     FIXME("\n");
1182     return E_NOTIMPL;
1183 }
1184
1185 static HRESULT WINAPI list_manager_GetTypeInfo(
1186     INetworkListManager *iface,
1187     UINT index,
1188     LCID lcid,
1189     ITypeInfo **info )
1190 {
1191     FIXME("\n");
1192     return E_NOTIMPL;
1193 }
1194
1195 static HRESULT WINAPI list_manager_GetIDsOfNames(
1196     INetworkListManager *iface,
1197     REFIID riid,
1198     LPOLESTR *names,
1199     UINT count,
1200     LCID lcid,
1201     DISPID *dispid )
1202 {
1203     FIXME("\n");
1204     return E_NOTIMPL;
1205 }
1206
1207 static HRESULT WINAPI list_manager_Invoke(
1208     INetworkListManager *iface,
1209     DISPID member,
1210     REFIID riid,
1211     LCID lcid,
1212     WORD flags,
1213     DISPPARAMS *params,
1214     VARIANT *result,
1215     EXCEPINFO *excep_info,
1216     UINT *arg_err )
1217 {
1218     FIXME("\n");
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI list_manager_GetNetworks(
1223     INetworkListManager *iface,
1224     NLM_ENUM_NETWORK Flags,
1225     IEnumNetworks **ppEnumNetwork )
1226 {
1227     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1228
1229     TRACE( "%p, %x, %p\n", iface, Flags, ppEnumNetwork );
1230     if (Flags) FIXME( "flags %08x not supported\n", Flags );
1231
1232     return create_networks_enum( mgr, ppEnumNetwork );
1233 }
1234
1235 static HRESULT WINAPI list_manager_GetNetwork(
1236     INetworkListManager *iface,
1237     GUID gdNetworkId,
1238     INetwork **ppNetwork )
1239 {
1240     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1241     struct network *network;
1242
1243     TRACE( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkId), ppNetwork );
1244
1245     LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry )
1246     {
1247         if (IsEqualGUID( &network->id, &gdNetworkId ))
1248         {
1249             *ppNetwork = &network->INetwork_iface;
1250             INetwork_AddRef( *ppNetwork );
1251             return S_OK;
1252         }
1253     }
1254
1255     return S_FALSE;
1256 }
1257
1258 static HRESULT WINAPI list_manager_GetNetworkConnections(
1259     INetworkListManager *iface,
1260     IEnumNetworkConnections **ppEnum )
1261 {
1262     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1263
1264     TRACE( "%p, %p\n", iface, ppEnum );
1265     return create_connections_enum( mgr, ppEnum );
1266 }
1267
1268 static HRESULT WINAPI list_manager_GetNetworkConnection(
1269     INetworkListManager *iface,
1270     GUID gdNetworkConnectionId,
1271     INetworkConnection **ppNetworkConnection )
1272 {
1273     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1274     struct connection *connection;
1275
1276     TRACE( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkConnectionId),
1277             ppNetworkConnection );
1278
1279     LIST_FOR_EACH_ENTRY( connection, &mgr->connections, struct connection, entry )
1280     {
1281         if (IsEqualGUID( &connection->id, &gdNetworkConnectionId ))
1282         {
1283             *ppNetworkConnection = &connection->INetworkConnection_iface;
1284             INetworkConnection_AddRef( *ppNetworkConnection );
1285             return S_OK;
1286         }
1287     }
1288
1289     return S_FALSE;
1290 }
1291
1292 static HRESULT WINAPI list_manager_IsConnectedToInternet(
1293     INetworkListManager *iface,
1294     VARIANT_BOOL *pbIsConnected )
1295 {
1296     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1297     struct network *network;
1298
1299     TRACE( "%p, %p\n", iface, pbIsConnected );
1300
1301     LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry )
1302     {
1303         if (network->connected_to_internet)
1304         {
1305             *pbIsConnected = VARIANT_TRUE;
1306             return S_OK;
1307         }
1308     }
1309
1310     *pbIsConnected = VARIANT_FALSE;
1311     return S_OK;
1312 }
1313
1314 static HRESULT WINAPI list_manager_IsConnected(
1315     INetworkListManager *iface,
1316     VARIANT_BOOL *pbIsConnected )
1317 {
1318     struct list_manager *mgr = impl_from_INetworkListManager( iface );
1319     struct network *network;
1320
1321     TRACE( "%p, %p\n", iface, pbIsConnected );
1322
1323     LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry )
1324     {
1325         if (network->connected)
1326         {
1327             *pbIsConnected = VARIANT_TRUE;
1328             return S_OK;
1329         }
1330     }
1331
1332     *pbIsConnected = VARIANT_FALSE;
1333     return S_OK;
1334 }
1335
1336 static HRESULT WINAPI list_manager_GetConnectivity(
1337     INetworkListManager *iface,
1338     NLM_CONNECTIVITY *pConnectivity )
1339 {
1340     FIXME( "%p, %p\n", iface, pConnectivity );
1341
1342     *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET;
1343     return S_OK;
1344 }
1345
1346 static const INetworkListManagerVtbl list_manager_vtbl =
1347 {
1348     list_manager_QueryInterface,
1349     list_manager_AddRef,
1350     list_manager_Release,
1351     list_manager_GetTypeInfoCount,
1352     list_manager_GetTypeInfo,
1353     list_manager_GetIDsOfNames,
1354     list_manager_Invoke,
1355     list_manager_GetNetworks,
1356     list_manager_GetNetwork,
1357     list_manager_GetNetworkConnections,
1358     list_manager_GetNetworkConnection,
1359     list_manager_IsConnectedToInternet,
1360     list_manager_IsConnected,
1361     list_manager_GetConnectivity
1362 };
1363
1364 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
1365                                                               REFIID riid, void **ppv)
1366 {
1367     struct list_manager *This = impl_from_IConnectionPointContainer( iface );
1368     return INetworkListManager_QueryInterface(&This->INetworkListManager_iface, riid, ppv);
1369 }
1370
1371 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
1372 {
1373     struct list_manager *This = impl_from_IConnectionPointContainer( iface );
1374     return INetworkListManager_AddRef(&This->INetworkListManager_iface);
1375 }
1376
1377 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
1378 {
1379     struct list_manager *This = impl_from_IConnectionPointContainer( iface );
1380     return INetworkListManager_Release(&This->INetworkListManager_iface);
1381 }
1382
1383 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
1384         IEnumConnectionPoints **ppEnum)
1385 {
1386     struct list_manager *This = impl_from_IConnectionPointContainer( iface );
1387     FIXME("(%p)->(%p): stub\n", This, ppEnum);
1388     return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
1392         REFIID riid, IConnectionPoint **cp)
1393 {
1394     struct list_manager *This = impl_from_IConnectionPointContainer( iface );
1395     struct connection_point *ret;
1396
1397     TRACE( "%p, %s, %p\n", This, debugstr_guid(riid), cp );
1398
1399     if (!riid || !cp)
1400         return E_POINTER;
1401
1402     if (IsEqualGUID( riid, &IID_INetworkListManagerEvents ))
1403         ret = &This->list_mgr_cp;
1404     else if (IsEqualGUID( riid, &IID_INetworkCostManagerEvents ))
1405         ret = &This->cost_mgr_cp;
1406     else if (IsEqualGUID( riid, &IID_INetworkConnectionEvents ))
1407         ret = &This->conn_mgr_cp;
1408     else
1409     {
1410         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1411         *cp = NULL;
1412         return E_NOINTERFACE;
1413     }
1414
1415     IConnectionPoint_AddRef( *cp = &ret->IConnectionPoint_iface );
1416     return S_OK;
1417 }
1418
1419 static const struct IConnectionPointContainerVtbl cpc_vtbl =
1420 {
1421     ConnectionPointContainer_QueryInterface,
1422     ConnectionPointContainer_AddRef,
1423     ConnectionPointContainer_Release,
1424     ConnectionPointContainer_EnumConnectionPoints,
1425     ConnectionPointContainer_FindConnectionPoint
1426 };
1427
1428 static inline struct connection *impl_from_INetworkConnection(
1429     INetworkConnection *iface )
1430 {
1431     return CONTAINING_RECORD( iface, struct connection, INetworkConnection_iface );
1432 }
1433
1434 static HRESULT WINAPI connection_QueryInterface(
1435     INetworkConnection *iface, REFIID riid, void **obj )
1436 {
1437     struct connection *connection = impl_from_INetworkConnection( iface );
1438
1439     TRACE( "%p, %s, %p\n", connection, debugstr_guid(riid), obj );
1440
1441     if (IsEqualIID( riid, &IID_INetworkConnection ) ||
1442         IsEqualIID( riid, &IID_IDispatch ) ||
1443         IsEqualIID( riid, &IID_IUnknown ))
1444     {
1445         *obj = iface;
1446     }
1447     else if (IsEqualIID( riid, &IID_INetworkConnectionCost ))
1448     {
1449         *obj = &connection->INetworkConnectionCost_iface;
1450     }
1451     else
1452     {
1453         WARN( "interface not supported %s\n", debugstr_guid(riid) );
1454         *obj = NULL;
1455         return E_NOINTERFACE;
1456     }
1457     INetworkConnection_AddRef( iface );
1458     return S_OK;
1459 }
1460
1461 static ULONG WINAPI connection_AddRef(
1462     INetworkConnection  *iface )
1463 {
1464     struct connection *connection = impl_from_INetworkConnection( iface );
1465
1466     TRACE( "%p\n", connection );
1467     return InterlockedIncrement( &connection->refs );
1468 }
1469
1470 static ULONG WINAPI connection_Release(
1471     INetworkConnection  *iface )
1472 {
1473     struct connection *connection = impl_from_INetworkConnection( iface );
1474     LONG refs;
1475
1476     TRACE( "%p\n", connection );
1477
1478     if (!(refs = InterlockedDecrement( &connection->refs )))
1479     {
1480         INetwork_Release( connection->network );
1481         list_remove( &connection->entry );
1482         heap_free( connection );
1483     }
1484     return refs;
1485 }
1486
1487 static HRESULT WINAPI connection_GetTypeInfoCount(
1488     INetworkConnection *iface,
1489     UINT *count )
1490 {
1491     FIXME("\n");
1492     return E_NOTIMPL;
1493 }
1494
1495 static HRESULT WINAPI connection_GetTypeInfo(
1496     INetworkConnection *iface,
1497     UINT index,
1498     LCID lcid,
1499     ITypeInfo **info )
1500 {
1501     FIXME("\n");
1502     return E_NOTIMPL;
1503 }
1504
1505 static HRESULT WINAPI connection_GetIDsOfNames(
1506     INetworkConnection *iface,
1507     REFIID riid,
1508     LPOLESTR *names,
1509     UINT count,
1510     LCID lcid,
1511     DISPID *dispid )
1512 {
1513     FIXME("\n");
1514     return E_NOTIMPL;
1515 }
1516
1517 static HRESULT WINAPI connection_Invoke(
1518     INetworkConnection *iface,
1519     DISPID member,
1520     REFIID riid,
1521     LCID lcid,
1522     WORD flags,
1523     DISPPARAMS *params,
1524     VARIANT *result,
1525     EXCEPINFO *excep_info,
1526     UINT *arg_err )
1527 {
1528     FIXME("\n");
1529     return E_NOTIMPL;
1530 }
1531
1532 static HRESULT WINAPI connection_GetNetwork(
1533     INetworkConnection *iface,
1534     INetwork **ppNetwork )
1535 {
1536     struct connection *connection = impl_from_INetworkConnection( iface );
1537
1538     TRACE( "%p, %p\n", iface, ppNetwork );
1539
1540     *ppNetwork = connection->network;
1541     INetwork_AddRef( *ppNetwork );
1542     return S_OK;
1543 }
1544
1545 static HRESULT WINAPI connection_get_IsConnectedToInternet(
1546     INetworkConnection *iface,
1547     VARIANT_BOOL *pbIsConnected )
1548 {
1549     struct connection *connection = impl_from_INetworkConnection( iface );
1550
1551     TRACE( "%p, %p\n", iface, pbIsConnected );
1552
1553     *pbIsConnected = connection->connected_to_internet;
1554     return S_OK;
1555 }
1556
1557 static HRESULT WINAPI connection_get_IsConnected(
1558     INetworkConnection *iface,
1559     VARIANT_BOOL *pbIsConnected )
1560 {
1561     struct connection *connection = impl_from_INetworkConnection( iface );
1562
1563     TRACE( "%p, %p\n", iface, pbIsConnected );
1564
1565     *pbIsConnected = connection->connected;
1566     return S_OK;
1567 }
1568
1569 static HRESULT WINAPI connection_GetConnectivity(
1570     INetworkConnection *iface,
1571     NLM_CONNECTIVITY *pConnectivity )
1572 {
1573     FIXME( "%p, %p\n", iface, pConnectivity );
1574
1575     *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET;
1576     return S_OK;
1577 }
1578
1579 static HRESULT WINAPI connection_GetConnectionId(
1580     INetworkConnection *iface,
1581     GUID *pgdConnectionId )
1582 {
1583     struct connection *connection = impl_from_INetworkConnection( iface );
1584
1585     TRACE( "%p, %p\n", iface, pgdConnectionId );
1586
1587     *pgdConnectionId = connection->id;
1588     return S_OK;
1589 }
1590
1591 static HRESULT WINAPI connection_GetAdapterId(
1592     INetworkConnection *iface,
1593     GUID *pgdAdapterId )
1594 {
1595     struct connection *connection = impl_from_INetworkConnection( iface );
1596
1597     FIXME( "%p, %p\n", iface, pgdAdapterId );
1598
1599     *pgdAdapterId = connection->id;
1600     return S_OK;
1601 }
1602
1603 static HRESULT WINAPI connection_GetDomainType(
1604     INetworkConnection *iface,
1605     NLM_DOMAIN_TYPE *pDomainType )
1606 {
1607     FIXME( "%p, %p\n", iface, pDomainType );
1608
1609     *pDomainType = NLM_DOMAIN_TYPE_NON_DOMAIN_NETWORK;
1610     return S_OK;
1611 }
1612
1613 static const struct INetworkConnectionVtbl connection_vtbl =
1614 {
1615     connection_QueryInterface,
1616     connection_AddRef,
1617     connection_Release,
1618     connection_GetTypeInfoCount,
1619     connection_GetTypeInfo,
1620     connection_GetIDsOfNames,
1621     connection_Invoke,
1622     connection_GetNetwork,
1623     connection_get_IsConnectedToInternet,
1624     connection_get_IsConnected,
1625     connection_GetConnectivity,
1626     connection_GetConnectionId,
1627     connection_GetAdapterId,
1628     connection_GetDomainType
1629 };
1630
1631 static inline struct connection *impl_from_INetworkConnectionCost(
1632     INetworkConnectionCost *iface )
1633 {
1634     return CONTAINING_RECORD( iface, struct connection, INetworkConnectionCost_iface );
1635 }
1636
1637 static HRESULT WINAPI connection_cost_QueryInterface(
1638     INetworkConnectionCost *iface,
1639     REFIID riid,
1640     void **obj )
1641 {
1642     struct connection *conn = impl_from_INetworkConnectionCost( iface );
1643     return INetworkConnection_QueryInterface( &conn->INetworkConnection_iface, riid, obj );
1644 }
1645
1646 static ULONG WINAPI connection_cost_AddRef(
1647     INetworkConnectionCost *iface )
1648 {
1649     struct connection *conn = impl_from_INetworkConnectionCost( iface );
1650     return INetworkConnection_AddRef( &conn->INetworkConnection_iface );
1651 }
1652
1653 static ULONG WINAPI connection_cost_Release(
1654     INetworkConnectionCost *iface )
1655 {
1656     struct connection *conn = impl_from_INetworkConnectionCost( iface );
1657     return INetworkConnection_Release( &conn->INetworkConnection_iface );
1658 }
1659
1660 static HRESULT WINAPI connection_cost_GetCost(
1661     INetworkConnectionCost *iface, DWORD *pCost )
1662 {
1663     FIXME( "%p, %p\n", iface, pCost );
1664
1665     if (!pCost) return E_POINTER;
1666
1667     *pCost = NLM_CONNECTION_COST_UNRESTRICTED;
1668     return S_OK;
1669 }
1670
1671 static HRESULT WINAPI connection_cost_GetDataPlanStatus(
1672     INetworkConnectionCost *iface, NLM_DATAPLAN_STATUS *pDataPlanStatus )
1673 {
1674     struct connection *conn = impl_from_INetworkConnectionCost( iface );
1675
1676     FIXME( "%p, %p\n", iface, pDataPlanStatus );
1677
1678     if (!pDataPlanStatus) return E_POINTER;
1679
1680     memcpy( &pDataPlanStatus->InterfaceGuid, &conn->id, sizeof(conn->id) );
1681     pDataPlanStatus->UsageData.UsageInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS;
1682     memset( &pDataPlanStatus->UsageData.LastSyncTime, 0, sizeof(pDataPlanStatus->UsageData.LastSyncTime) );
1683     pDataPlanStatus->DataLimitInMegabytes       = NLM_UNKNOWN_DATAPLAN_STATUS;
1684     pDataPlanStatus->InboundBandwidthInKbps     = NLM_UNKNOWN_DATAPLAN_STATUS;
1685     pDataPlanStatus->OutboundBandwidthInKbps    = NLM_UNKNOWN_DATAPLAN_STATUS;
1686     memset( &pDataPlanStatus->NextBillingCycle, 0, sizeof(pDataPlanStatus->NextBillingCycle) );
1687     pDataPlanStatus->MaxTransferSizeInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS;
1688     pDataPlanStatus->Reserved                   = 0;
1689
1690     return S_OK;
1691 }
1692
1693 static const INetworkConnectionCostVtbl connection_cost_vtbl =
1694 {
1695     connection_cost_QueryInterface,
1696     connection_cost_AddRef,
1697     connection_cost_Release,
1698     connection_cost_GetCost,
1699     connection_cost_GetDataPlanStatus
1700 };
1701
1702 static struct connection *create_connection( const GUID *id )
1703 {
1704     struct connection *ret;
1705
1706     if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
1707
1708     ret->INetworkConnection_iface.lpVtbl     = &connection_vtbl;
1709     ret->INetworkConnectionCost_iface.lpVtbl = &connection_cost_vtbl;
1710     ret->refs                  = 1;
1711     ret->id                    = *id;
1712     ret->network               = NULL;
1713     ret->connected             = VARIANT_FALSE;
1714     ret->connected_to_internet = VARIANT_FALSE;
1715     list_init( &ret->entry );
1716
1717     return ret;
1718 }
1719
1720 static void init_networks( struct list_manager *mgr )
1721 {
1722     DWORD size = 0;
1723     IP_ADAPTER_ADDRESSES *buf, *aa;
1724     GUID id;
1725     ULONG ret, flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
1726                        GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_ALL_GATEWAYS;
1727
1728     list_init( &mgr->networks );
1729     list_init( &mgr->connections );
1730
1731     ret = GetAdaptersAddresses( WS_AF_UNSPEC, flags, NULL, NULL, &size );
1732     if (ret != ERROR_BUFFER_OVERFLOW) return;
1733
1734     if (!(buf = heap_alloc( size ))) return;
1735     if (GetAdaptersAddresses( WS_AF_UNSPEC, flags, NULL, buf, &size ))
1736     {
1737         heap_free( buf );
1738         return;
1739     }
1740
1741     memset( &id, 0, sizeof(id) );
1742     for (aa = buf; aa; aa = aa->Next)
1743     {
1744         struct network *network;
1745         struct connection *connection;
1746
1747         id.Data1 = aa->u.s.IfIndex;
1748
1749         /* assume a one-to-one mapping between networks and connections */
1750         if (!(network = create_network( &id ))) goto done;
1751         if (!(connection = create_connection( &id )))
1752         {
1753             INetwork_Release( &network->INetwork_iface );
1754             goto done;
1755         }
1756
1757         if (aa->FirstUnicastAddress)
1758         {
1759             network->connected = VARIANT_TRUE;
1760             connection->connected = VARIANT_TRUE;
1761         }
1762         if (aa->FirstGatewayAddress)
1763         {
1764             network->connected_to_internet = VARIANT_TRUE;
1765             connection->connected_to_internet = VARIANT_TRUE;
1766         }
1767
1768         connection->network = &network->INetwork_iface;
1769         INetwork_AddRef( connection->network );
1770
1771         list_add_tail( &mgr->networks, &network->entry );
1772         list_add_tail( &mgr->connections, &connection->entry );
1773     }
1774
1775 done:
1776     heap_free( buf );
1777 }
1778
1779 HRESULT list_manager_create( void **obj )
1780 {
1781     struct list_manager *mgr;
1782
1783     TRACE( "%p\n", obj );
1784
1785     if (!(mgr = heap_alloc( sizeof(*mgr) ))) return E_OUTOFMEMORY;
1786     mgr->INetworkListManager_iface.lpVtbl = &list_manager_vtbl;
1787     mgr->INetworkCostManager_iface.lpVtbl = &cost_manager_vtbl;
1788     mgr->IConnectionPointContainer_iface.lpVtbl = &cpc_vtbl;
1789     init_networks( mgr );
1790     mgr->refs = 1;
1791
1792     connection_point_init( &mgr->list_mgr_cp, &IID_INetworkListManagerEvents,
1793                            &mgr->IConnectionPointContainer_iface );
1794     connection_point_init( &mgr->cost_mgr_cp, &IID_INetworkCostManagerEvents,
1795                            &mgr->IConnectionPointContainer_iface);
1796     connection_point_init( &mgr->conn_mgr_cp, &IID_INetworkConnectionEvents,
1797                            &mgr->IConnectionPointContainer_iface );
1798
1799     *obj = &mgr->INetworkListManager_iface;
1800     TRACE( "returning iface %p\n", *obj );
1801     return S_OK;
1802 }