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