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