/* * Copyright 2014 Hans Leidekker for CodeWeavers * Copyright 2015 Michael Müller * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #define COBJMACROS #define NONAMELESSUNION #define NONAMELESSSTRUCT #include <stdarg.h> #include "windef.h" #include "winbase.h" #include "winsock2.h" #include "ws2ipdef.h" #include "iphlpapi.h" #include "ifdef.h" #include "netioapi.h" #include "initguid.h" #include "objbase.h" #include "ocidl.h" #include "netlistmgr.h" #include "olectl.h" #include "wine/debug.h" #include "wine/heap.h" #include "wine/list.h" #include "netprofm_private.h" WINE_DEFAULT_DEBUG_CHANNEL(netprofm); struct network { INetwork INetwork_iface; LONG refs; struct list entry; GUID id; VARIANT_BOOL connected_to_internet; VARIANT_BOOL connected; }; struct connection { INetworkConnection INetworkConnection_iface; INetworkConnectionCost INetworkConnectionCost_iface; LONG refs; struct list entry; GUID id; INetwork *network; VARIANT_BOOL connected_to_internet; VARIANT_BOOL connected; }; struct connection_point { IConnectionPoint IConnectionPoint_iface; IConnectionPointContainer *container; IID iid; struct list sinks; DWORD cookie; }; struct list_manager { INetworkListManager INetworkListManager_iface; INetworkCostManager INetworkCostManager_iface; IConnectionPointContainer IConnectionPointContainer_iface; LONG refs; struct list networks; struct list connections; struct connection_point list_mgr_cp; struct connection_point cost_mgr_cp; struct connection_point conn_mgr_cp; struct connection_point events_cp; }; struct sink_entry { struct list entry; DWORD cookie; IUnknown *unk; }; static inline struct list_manager *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface) { return CONTAINING_RECORD(iface, struct list_manager, IConnectionPointContainer_iface); } static inline struct list_manager *impl_from_INetworkCostManager( INetworkCostManager *iface ) { return CONTAINING_RECORD( iface, struct list_manager, INetworkCostManager_iface ); } static inline struct connection_point *impl_from_IConnectionPoint( IConnectionPoint *iface ) { return CONTAINING_RECORD( iface, struct connection_point, IConnectionPoint_iface ); } static HRESULT WINAPI connection_point_QueryInterface( IConnectionPoint *iface, REFIID riid, void **obj ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); TRACE( "%p, %s, %p\n", cp, debugstr_guid(riid), obj ); if (IsEqualGUID( riid, &IID_IConnectionPoint ) || IsEqualGUID( riid, &IID_IUnknown )) { *obj = iface; } else { FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } IConnectionPoint_AddRef( iface ); return S_OK; } static ULONG WINAPI connection_point_AddRef( IConnectionPoint *iface ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); return IConnectionPointContainer_AddRef( cp->container ); } static ULONG WINAPI connection_point_Release( IConnectionPoint *iface ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); return IConnectionPointContainer_Release( cp->container ); } static HRESULT WINAPI connection_point_GetConnectionInterface( IConnectionPoint *iface, IID *iid ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); TRACE( "%p, %p\n", cp, iid ); if (!iid) return E_POINTER; memcpy( iid, &cp->iid, sizeof(*iid) ); return S_OK; } static HRESULT WINAPI connection_point_GetConnectionPointContainer( IConnectionPoint *iface, IConnectionPointContainer **container ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); TRACE( "%p, %p\n", cp, container ); if (!container) return E_POINTER; IConnectionPointContainer_AddRef( cp->container ); *container = cp->container; return S_OK; } static HRESULT WINAPI connection_point_Advise( IConnectionPoint *iface, IUnknown *sink, DWORD *cookie ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); struct sink_entry *sink_entry; IUnknown *unk; HRESULT hr; FIXME( "%p, %p, %p - semi-stub\n", cp, sink, cookie ); if (!sink || !cookie) return E_POINTER; hr = IUnknown_QueryInterface( sink, &cp->iid, (void**)&unk ); if (FAILED(hr)) { WARN( "iface %s not implemented by sink\n", debugstr_guid(&cp->iid) ); return CO_E_FAILEDTOOPENTHREADTOKEN; } sink_entry = heap_alloc( sizeof(*sink_entry) ); if (!sink_entry) { IUnknown_Release( unk ); return E_OUTOFMEMORY; } sink_entry->unk = unk; *cookie = sink_entry->cookie = ++cp->cookie; list_add_tail( &cp->sinks, &sink_entry->entry ); return S_OK; } static void sink_entry_release( struct sink_entry *entry ) { list_remove( &entry->entry ); IUnknown_Release( entry->unk ); heap_free( entry ); } static HRESULT WINAPI connection_point_Unadvise( IConnectionPoint *iface, DWORD cookie ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); struct sink_entry *iter; TRACE( "%p, %d\n", cp, cookie ); LIST_FOR_EACH_ENTRY( iter, &cp->sinks, struct sink_entry, entry ) { if (iter->cookie != cookie) continue; sink_entry_release( iter ); return S_OK; } WARN( "invalid cookie\n" ); return OLE_E_NOCONNECTION; } static HRESULT WINAPI connection_point_EnumConnections( IConnectionPoint *iface, IEnumConnections **connections ) { struct connection_point *cp = impl_from_IConnectionPoint( iface ); FIXME( "%p, %p - stub\n", cp, connections ); return E_NOTIMPL; } static const IConnectionPointVtbl connection_point_vtbl = { connection_point_QueryInterface, connection_point_AddRef, connection_point_Release, connection_point_GetConnectionInterface, connection_point_GetConnectionPointContainer, connection_point_Advise, connection_point_Unadvise, connection_point_EnumConnections }; static void connection_point_init( struct connection_point *cp, REFIID riid, IConnectionPointContainer *container ) { cp->IConnectionPoint_iface.lpVtbl = &connection_point_vtbl; cp->container = container; cp->cookie = 0; cp->iid = *riid; list_init( &cp->sinks ); } static void connection_point_release( struct connection_point *cp ) { while (!list_empty( &cp->sinks )) sink_entry_release( LIST_ENTRY( list_head( &cp->sinks ), struct sink_entry, entry ) ); } static inline struct network *impl_from_INetwork( INetwork *iface ) { return CONTAINING_RECORD( iface, struct network, INetwork_iface ); } static HRESULT WINAPI network_QueryInterface( INetwork *iface, REFIID riid, void **obj ) { struct network *network = impl_from_INetwork( iface ); TRACE( "%p, %s, %p\n", network, debugstr_guid(riid), obj ); if (IsEqualIID( riid, &IID_INetwork ) || IsEqualIID( riid, &IID_IDispatch ) || IsEqualIID( riid, &IID_IUnknown )) { *obj = iface; INetwork_AddRef( iface ); return S_OK; } else { WARN( "interface not supported %s\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } } static ULONG WINAPI network_AddRef( INetwork *iface ) { struct network *network = impl_from_INetwork( iface ); TRACE( "%p\n", network ); return InterlockedIncrement( &network->refs ); } static ULONG WINAPI network_Release( INetwork *iface ) { struct network *network = impl_from_INetwork( iface ); LONG refs; TRACE( "%p\n", network ); if (!(refs = InterlockedDecrement( &network->refs ))) { list_remove( &network->entry ); heap_free( network ); } return refs; } static HRESULT WINAPI network_GetTypeInfoCount( INetwork *iface, UINT *count ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI network_GetTypeInfo( INetwork *iface, UINT index, LCID lcid, ITypeInfo **info ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI network_GetIDsOfNames( INetwork *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI network_Invoke( INetwork *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI network_GetName( INetwork *iface, BSTR *pszNetworkName ) { FIXME( "%p, %p\n", iface, pszNetworkName ); return E_NOTIMPL; } static HRESULT WINAPI network_SetName( INetwork *iface, BSTR szNetworkNewName ) { FIXME( "%p, %s\n", iface, debugstr_w(szNetworkNewName) ); return E_NOTIMPL; } static HRESULT WINAPI network_GetDescription( INetwork *iface, BSTR *pszDescription ) { FIXME( "%p, %p\n", iface, pszDescription ); return E_NOTIMPL; } static HRESULT WINAPI network_SetDescription( INetwork *iface, BSTR szDescription ) { FIXME( "%p, %s\n", iface, debugstr_w(szDescription) ); return E_NOTIMPL; } static HRESULT WINAPI network_GetNetworkId( INetwork *iface, GUID *pgdGuidNetworkId ) { struct network *network = impl_from_INetwork( iface ); TRACE( "%p, %p\n", iface, pgdGuidNetworkId ); *pgdGuidNetworkId = network->id; return S_OK; } static HRESULT WINAPI network_GetDomainType( INetwork *iface, NLM_DOMAIN_TYPE *pDomainType ) { FIXME( "%p, %p\n", iface, pDomainType ); *pDomainType = NLM_DOMAIN_TYPE_NON_DOMAIN_NETWORK; return S_OK; } static HRESULT WINAPI network_GetNetworkConnections( INetwork *iface, IEnumNetworkConnections **ppEnumNetworkConnection ) { FIXME( "%p, %p\n", iface, ppEnumNetworkConnection ); return E_NOTIMPL; } static HRESULT WINAPI network_GetTimeCreatedAndConnected( INetwork *iface, DWORD *pdwLowDateTimeCreated, DWORD *pdwHighDateTimeCreated, DWORD *pdwLowDateTimeConnected, DWORD *pdwHighDateTimeConnected ) { FIXME( "%p, %p, %p, %p, %p\n", iface, pdwLowDateTimeCreated, pdwHighDateTimeCreated, pdwLowDateTimeConnected, pdwHighDateTimeConnected ); return E_NOTIMPL; } static HRESULT WINAPI network_get_IsConnectedToInternet( INetwork *iface, VARIANT_BOOL *pbIsConnected ) { struct network *network = impl_from_INetwork( iface ); TRACE( "%p, %p\n", iface, pbIsConnected ); *pbIsConnected = network->connected_to_internet; return S_OK; } static HRESULT WINAPI network_get_IsConnected( INetwork *iface, VARIANT_BOOL *pbIsConnected ) { struct network *network = impl_from_INetwork( iface ); TRACE( "%p, %p\n", iface, pbIsConnected ); *pbIsConnected = network->connected; return S_OK; } static HRESULT WINAPI network_GetConnectivity( INetwork *iface, NLM_CONNECTIVITY *pConnectivity ) { FIXME( "%p, %p\n", iface, pConnectivity ); *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET; return S_OK; } static HRESULT WINAPI network_GetCategory( INetwork *iface, NLM_NETWORK_CATEGORY *pCategory ) { FIXME( "%p, %p\n", iface, pCategory ); *pCategory = NLM_NETWORK_CATEGORY_PUBLIC; return S_OK; } static HRESULT WINAPI network_SetCategory( INetwork *iface, NLM_NETWORK_CATEGORY NewCategory ) { FIXME( "%p, %u\n", iface, NewCategory ); return E_NOTIMPL; } static const struct INetworkVtbl network_vtbl = { network_QueryInterface, network_AddRef, network_Release, network_GetTypeInfoCount, network_GetTypeInfo, network_GetIDsOfNames, network_Invoke, network_GetName, network_SetName, network_GetDescription, network_SetDescription, network_GetNetworkId, network_GetDomainType, network_GetNetworkConnections, network_GetTimeCreatedAndConnected, network_get_IsConnectedToInternet, network_get_IsConnected, network_GetConnectivity, network_GetCategory, network_SetCategory }; static struct network *create_network( const GUID *id ) { struct network *ret; if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL; ret->INetwork_iface.lpVtbl = &network_vtbl; ret->refs = 1; ret->id = *id; ret->connected = VARIANT_FALSE; ret->connected_to_internet = VARIANT_FALSE; list_init( &ret->entry ); return ret; } static HRESULT WINAPI cost_manager_QueryInterface( INetworkCostManager *iface, REFIID riid, void **obj ) { struct list_manager *mgr = impl_from_INetworkCostManager( iface ); return INetworkListManager_QueryInterface( &mgr->INetworkListManager_iface, riid, obj ); } static ULONG WINAPI cost_manager_AddRef( INetworkCostManager *iface ) { struct list_manager *mgr = impl_from_INetworkCostManager( iface ); return INetworkListManager_AddRef( &mgr->INetworkListManager_iface ); } static ULONG WINAPI cost_manager_Release( INetworkCostManager *iface ) { struct list_manager *mgr = impl_from_INetworkCostManager( iface ); return INetworkListManager_Release( &mgr->INetworkListManager_iface ); } static HRESULT WINAPI cost_manager_GetCost( INetworkCostManager *iface, DWORD *pCost, NLM_SOCKADDR *pDestIPAddr) { FIXME( "%p, %p, %p\n", iface, pCost, pDestIPAddr ); if (!pCost) return E_POINTER; *pCost = NLM_CONNECTION_COST_UNRESTRICTED; return S_OK; } static BOOL map_address_6to4( const SOCKADDR_IN6 *addr6, SOCKADDR_IN *addr4 ) { ULONG i; if (addr6->sin6_family != AF_INET6) return FALSE; for (i = 0; i < 5; i++) if (addr6->sin6_addr.u.Word[i]) return FALSE; if (addr6->sin6_addr.u.Word[5] != 0xffff) return FALSE; addr4->sin_family = AF_INET; addr4->sin_port = addr6->sin6_port; addr4->sin_addr.S_un.S_addr = addr6->sin6_addr.u.Word[6] << 16 | addr6->sin6_addr.u.Word[7]; memset( &addr4->sin_zero, 0, sizeof(addr4->sin_zero) ); return TRUE; } static HRESULT WINAPI cost_manager_GetDataPlanStatus( INetworkCostManager *iface, NLM_DATAPLAN_STATUS *pDataPlanStatus, NLM_SOCKADDR *pDestIPAddr) { DWORD ret, index; NET_LUID luid; SOCKADDR *dst = (SOCKADDR *)pDestIPAddr; SOCKADDR_IN addr4, *dst4; FIXME( "%p, %p, %p\n", iface, pDataPlanStatus, pDestIPAddr ); if (!pDataPlanStatus) return E_POINTER; if (dst && ((dst->sa_family == AF_INET && (dst4 = (SOCKADDR_IN *)dst)) || ((dst->sa_family == AF_INET6 && map_address_6to4( (const SOCKADDR_IN6 *)dst, &addr4 ) && (dst4 = &addr4))))) { if ((ret = GetBestInterface( dst4->sin_addr.S_un.S_addr, &index ))) return HRESULT_FROM_WIN32( ret ); if ((ret = ConvertInterfaceIndexToLuid( index, &luid ))) return HRESULT_FROM_WIN32( ret ); if ((ret = ConvertInterfaceLuidToGuid( &luid, &pDataPlanStatus->InterfaceGuid ))) return HRESULT_FROM_WIN32( ret ); } else { FIXME( "interface guid not found\n" ); memset( &pDataPlanStatus->InterfaceGuid, 0, sizeof(pDataPlanStatus->InterfaceGuid) ); } pDataPlanStatus->UsageData.UsageInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; memset( &pDataPlanStatus->UsageData.LastSyncTime, 0, sizeof(pDataPlanStatus->UsageData.LastSyncTime) ); pDataPlanStatus->DataLimitInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->InboundBandwidthInKbps = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->OutboundBandwidthInKbps = NLM_UNKNOWN_DATAPLAN_STATUS; memset( &pDataPlanStatus->NextBillingCycle, 0, sizeof(pDataPlanStatus->NextBillingCycle) ); pDataPlanStatus->MaxTransferSizeInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->Reserved = 0; return S_OK; } static HRESULT WINAPI cost_manager_SetDestinationAddresses( INetworkCostManager *iface, UINT32 length, NLM_SOCKADDR *pDestIPAddrList, VARIANT_BOOL bAppend) { FIXME( "%p, %u, %p, %x\n", iface, length, pDestIPAddrList, bAppend ); return E_NOTIMPL; } static const INetworkCostManagerVtbl cost_manager_vtbl = { cost_manager_QueryInterface, cost_manager_AddRef, cost_manager_Release, cost_manager_GetCost, cost_manager_GetDataPlanStatus, cost_manager_SetDestinationAddresses }; struct networks_enum { IEnumNetworks IEnumNetworks_iface; LONG refs; struct list_manager *mgr; struct list *cursor; }; static inline struct networks_enum *impl_from_IEnumNetworks( IEnumNetworks *iface ) { return CONTAINING_RECORD( iface, struct networks_enum, IEnumNetworks_iface ); } static HRESULT WINAPI networks_enum_QueryInterface( IEnumNetworks *iface, REFIID riid, void **obj ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); TRACE( "%p, %s, %p\n", iter, debugstr_guid(riid), obj ); if (IsEqualIID( riid, &IID_IEnumNetworks ) || IsEqualIID( riid, &IID_IDispatch ) || IsEqualIID( riid, &IID_IUnknown )) { *obj = iface; IEnumNetworks_AddRef( iface ); return S_OK; } else { WARN( "interface not supported %s\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } } static ULONG WINAPI networks_enum_AddRef( IEnumNetworks *iface ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); TRACE( "%p\n", iter ); return InterlockedIncrement( &iter->refs ); } static ULONG WINAPI networks_enum_Release( IEnumNetworks *iface ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); LONG refs; TRACE( "%p\n", iter ); if (!(refs = InterlockedDecrement( &iter->refs ))) { INetworkListManager_Release( &iter->mgr->INetworkListManager_iface ); heap_free( iter ); } return refs; } static HRESULT WINAPI networks_enum_GetTypeInfoCount( IEnumNetworks *iface, UINT *count ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI networks_enum_GetTypeInfo( IEnumNetworks *iface, UINT index, LCID lcid, ITypeInfo **info ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI networks_enum_GetIDsOfNames( IEnumNetworks *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI networks_enum_Invoke( IEnumNetworks *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI networks_enum_get__NewEnum( IEnumNetworks *iface, IEnumVARIANT **ppEnumVar ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI networks_enum_Next( IEnumNetworks *iface, ULONG count, INetwork **ret, ULONG *fetched ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); ULONG i = 0; TRACE( "%p, %u %p %p\n", iter, count, ret, fetched ); if (fetched) *fetched = 0; if (!count) return S_OK; while (iter->cursor && i < count) { struct network *network = LIST_ENTRY( iter->cursor, struct network, entry ); ret[i] = &network->INetwork_iface; INetwork_AddRef( ret[i] ); iter->cursor = list_next( &iter->mgr->networks, iter->cursor ); i++; } if (fetched) *fetched = i; return i < count ? S_FALSE : S_OK; } static HRESULT WINAPI networks_enum_Skip( IEnumNetworks *iface, ULONG count ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); TRACE( "%p, %u\n", iter, count); if (!count) return S_OK; if (!iter->cursor) return S_FALSE; while (count--) { iter->cursor = list_next( &iter->mgr->networks, iter->cursor ); if (!iter->cursor) break; } return count ? S_FALSE : S_OK; } static HRESULT WINAPI networks_enum_Reset( IEnumNetworks *iface ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); TRACE( "%p\n", iter ); iter->cursor = list_head( &iter->mgr->networks ); return S_OK; } static HRESULT create_networks_enum( struct list_manager *, IEnumNetworks** ); static HRESULT WINAPI networks_enum_Clone( IEnumNetworks *iface, IEnumNetworks **ret ) { struct networks_enum *iter = impl_from_IEnumNetworks( iface ); TRACE( "%p, %p\n", iter, ret ); return create_networks_enum( iter->mgr, ret ); } static const IEnumNetworksVtbl networks_enum_vtbl = { networks_enum_QueryInterface, networks_enum_AddRef, networks_enum_Release, networks_enum_GetTypeInfoCount, networks_enum_GetTypeInfo, networks_enum_GetIDsOfNames, networks_enum_Invoke, networks_enum_get__NewEnum, networks_enum_Next, networks_enum_Skip, networks_enum_Reset, networks_enum_Clone }; static HRESULT create_networks_enum( struct list_manager *mgr, IEnumNetworks **ret ) { struct networks_enum *iter; *ret = NULL; if (!(iter = heap_alloc( sizeof(*iter) ))) return E_OUTOFMEMORY; iter->IEnumNetworks_iface.lpVtbl = &networks_enum_vtbl; iter->cursor = list_head( &mgr->networks ); iter->mgr = mgr; INetworkListManager_AddRef( &mgr->INetworkListManager_iface ); iter->refs = 1; *ret = &iter->IEnumNetworks_iface; return S_OK; } static inline struct list_manager *impl_from_INetworkListManager( INetworkListManager *iface ) { return CONTAINING_RECORD( iface, struct list_manager, INetworkListManager_iface ); } struct connections_enum { IEnumNetworkConnections IEnumNetworkConnections_iface; LONG refs; struct list_manager *mgr; struct list *cursor; }; static inline struct connections_enum *impl_from_IEnumNetworkConnections( IEnumNetworkConnections *iface ) { return CONTAINING_RECORD( iface, struct connections_enum, IEnumNetworkConnections_iface ); } static HRESULT WINAPI connections_enum_QueryInterface( IEnumNetworkConnections *iface, REFIID riid, void **obj ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); TRACE( "%p, %s, %p\n", iter, debugstr_guid(riid), obj ); if (IsEqualIID( riid, &IID_IEnumNetworkConnections ) || IsEqualIID( riid, &IID_IDispatch ) || IsEqualIID( riid, &IID_IUnknown )) { *obj = iface; IEnumNetworkConnections_AddRef( iface ); return S_OK; } else { WARN( "interface not supported %s\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } } static ULONG WINAPI connections_enum_AddRef( IEnumNetworkConnections *iface ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); TRACE( "%p\n", iter ); return InterlockedIncrement( &iter->refs ); } static ULONG WINAPI connections_enum_Release( IEnumNetworkConnections *iface ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); LONG refs; TRACE( "%p\n", iter ); if (!(refs = InterlockedDecrement( &iter->refs ))) { INetworkListManager_Release( &iter->mgr->INetworkListManager_iface ); heap_free( iter ); } return refs; } static HRESULT WINAPI connections_enum_GetTypeInfoCount( IEnumNetworkConnections *iface, UINT *count ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connections_enum_GetTypeInfo( IEnumNetworkConnections *iface, UINT index, LCID lcid, ITypeInfo **info ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connections_enum_GetIDsOfNames( IEnumNetworkConnections *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connections_enum_Invoke( IEnumNetworkConnections *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connections_enum_get__NewEnum( IEnumNetworkConnections *iface, IEnumVARIANT **ppEnumVar ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connections_enum_Next( IEnumNetworkConnections *iface, ULONG count, INetworkConnection **ret, ULONG *fetched ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); ULONG i = 0; TRACE( "%p, %u %p %p\n", iter, count, ret, fetched ); if (!ret) return E_POINTER; *ret = NULL; if (fetched) *fetched = 0; if (!count) return S_OK; while (iter->cursor && i < count) { struct connection *connection = LIST_ENTRY( iter->cursor, struct connection, entry ); ret[i] = &connection->INetworkConnection_iface; INetworkConnection_AddRef( ret[i] ); iter->cursor = list_next( &iter->mgr->connections, iter->cursor ); i++; } if (fetched) *fetched = i; return i < count ? S_FALSE : S_OK; } static HRESULT WINAPI connections_enum_Skip( IEnumNetworkConnections *iface, ULONG count ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); TRACE( "%p, %u\n", iter, count); if (!count) return S_OK; if (!iter->cursor) return S_FALSE; while (count--) { iter->cursor = list_next( &iter->mgr->connections, iter->cursor ); if (!iter->cursor) break; } return count ? S_FALSE : S_OK; } static HRESULT WINAPI connections_enum_Reset( IEnumNetworkConnections *iface ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); TRACE( "%p\n", iter ); iter->cursor = list_head( &iter->mgr->connections ); return S_OK; } static HRESULT create_connections_enum( struct list_manager *, IEnumNetworkConnections** ); static HRESULT WINAPI connections_enum_Clone( IEnumNetworkConnections *iface, IEnumNetworkConnections **ret ) { struct connections_enum *iter = impl_from_IEnumNetworkConnections( iface ); TRACE( "%p, %p\n", iter, ret ); return create_connections_enum( iter->mgr, ret ); } static const IEnumNetworkConnectionsVtbl connections_enum_vtbl = { connections_enum_QueryInterface, connections_enum_AddRef, connections_enum_Release, connections_enum_GetTypeInfoCount, connections_enum_GetTypeInfo, connections_enum_GetIDsOfNames, connections_enum_Invoke, connections_enum_get__NewEnum, connections_enum_Next, connections_enum_Skip, connections_enum_Reset, connections_enum_Clone }; static HRESULT create_connections_enum( struct list_manager *mgr, IEnumNetworkConnections **ret ) { struct connections_enum *iter; *ret = NULL; if (!(iter = heap_alloc( sizeof(*iter) ))) return E_OUTOFMEMORY; iter->IEnumNetworkConnections_iface.lpVtbl = &connections_enum_vtbl; iter->mgr = mgr; INetworkListManager_AddRef( &mgr->INetworkListManager_iface ); iter->cursor = list_head( &iter->mgr->connections ); iter->refs = 1; *ret = &iter->IEnumNetworkConnections_iface; return S_OK; } static ULONG WINAPI list_manager_AddRef( INetworkListManager *iface ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); return InterlockedIncrement( &mgr->refs ); } static ULONG WINAPI list_manager_Release( INetworkListManager *iface ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); LONG refs = InterlockedDecrement( &mgr->refs ); if (!refs) { struct list *ptr; TRACE( "destroying %p\n", mgr ); connection_point_release( &mgr->events_cp ); connection_point_release( &mgr->conn_mgr_cp ); connection_point_release( &mgr->cost_mgr_cp ); connection_point_release( &mgr->list_mgr_cp ); while ((ptr = list_head( &mgr->networks ))) { struct network *network = LIST_ENTRY( ptr, struct network, entry ); list_remove( &network->entry ); INetwork_Release( &network->INetwork_iface ); } while ((ptr = list_head( &mgr->connections ))) { struct connection *connection = LIST_ENTRY( ptr, struct connection, entry ); list_remove( &connection->entry ); INetworkConnection_Release( &connection->INetworkConnection_iface ); } heap_free( mgr ); } return refs; } static HRESULT WINAPI list_manager_QueryInterface( INetworkListManager *iface, REFIID riid, void **obj ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); TRACE( "%p, %s, %p\n", mgr, debugstr_guid(riid), obj ); if (IsEqualGUID( riid, &IID_INetworkListManager ) || IsEqualGUID( riid, &IID_IDispatch ) || IsEqualGUID( riid, &IID_IUnknown )) { *obj = iface; } else if (IsEqualGUID( riid, &IID_INetworkCostManager )) { *obj = &mgr->INetworkCostManager_iface; } else if (IsEqualGUID( riid, &IID_IConnectionPointContainer )) { *obj = &mgr->IConnectionPointContainer_iface; } else { FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } INetworkListManager_AddRef( iface ); return S_OK; } static HRESULT WINAPI list_manager_GetTypeInfoCount( INetworkListManager *iface, UINT *count ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI list_manager_GetTypeInfo( INetworkListManager *iface, UINT index, LCID lcid, ITypeInfo **info ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI list_manager_GetIDsOfNames( INetworkListManager *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI list_manager_Invoke( INetworkListManager *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI list_manager_GetNetworks( INetworkListManager *iface, NLM_ENUM_NETWORK Flags, IEnumNetworks **ppEnumNetwork ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); TRACE( "%p, %x, %p\n", iface, Flags, ppEnumNetwork ); if (Flags) FIXME( "flags %08x not supported\n", Flags ); return create_networks_enum( mgr, ppEnumNetwork ); } static HRESULT WINAPI list_manager_GetNetwork( INetworkListManager *iface, GUID gdNetworkId, INetwork **ppNetwork ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); struct network *network; TRACE( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkId), ppNetwork ); LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry ) { if (IsEqualGUID( &network->id, &gdNetworkId )) { *ppNetwork = &network->INetwork_iface; INetwork_AddRef( *ppNetwork ); return S_OK; } } return S_FALSE; } static HRESULT WINAPI list_manager_GetNetworkConnections( INetworkListManager *iface, IEnumNetworkConnections **ppEnum ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); TRACE( "%p, %p\n", iface, ppEnum ); return create_connections_enum( mgr, ppEnum ); } static HRESULT WINAPI list_manager_GetNetworkConnection( INetworkListManager *iface, GUID gdNetworkConnectionId, INetworkConnection **ppNetworkConnection ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); struct connection *connection; TRACE( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkConnectionId), ppNetworkConnection ); LIST_FOR_EACH_ENTRY( connection, &mgr->connections, struct connection, entry ) { if (IsEqualGUID( &connection->id, &gdNetworkConnectionId )) { *ppNetworkConnection = &connection->INetworkConnection_iface; INetworkConnection_AddRef( *ppNetworkConnection ); return S_OK; } } return S_FALSE; } static HRESULT WINAPI list_manager_IsConnectedToInternet( INetworkListManager *iface, VARIANT_BOOL *pbIsConnected ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); struct network *network; TRACE( "%p, %p\n", iface, pbIsConnected ); LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry ) { if (network->connected_to_internet) { *pbIsConnected = VARIANT_TRUE; return S_OK; } } *pbIsConnected = VARIANT_FALSE; return S_OK; } static HRESULT WINAPI list_manager_IsConnected( INetworkListManager *iface, VARIANT_BOOL *pbIsConnected ) { struct list_manager *mgr = impl_from_INetworkListManager( iface ); struct network *network; TRACE( "%p, %p\n", iface, pbIsConnected ); LIST_FOR_EACH_ENTRY( network, &mgr->networks, struct network, entry ) { if (network->connected) { *pbIsConnected = VARIANT_TRUE; return S_OK; } } *pbIsConnected = VARIANT_FALSE; return S_OK; } static HRESULT WINAPI list_manager_GetConnectivity( INetworkListManager *iface, NLM_CONNECTIVITY *pConnectivity ) { FIXME( "%p, %p\n", iface, pConnectivity ); *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET; return S_OK; } static const INetworkListManagerVtbl list_manager_vtbl = { list_manager_QueryInterface, list_manager_AddRef, list_manager_Release, list_manager_GetTypeInfoCount, list_manager_GetTypeInfo, list_manager_GetIDsOfNames, list_manager_Invoke, list_manager_GetNetworks, list_manager_GetNetwork, list_manager_GetNetworkConnections, list_manager_GetNetworkConnection, list_manager_IsConnectedToInternet, list_manager_IsConnected, list_manager_GetConnectivity }; static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface, REFIID riid, void **ppv) { struct list_manager *This = impl_from_IConnectionPointContainer( iface ); return INetworkListManager_QueryInterface(&This->INetworkListManager_iface, riid, ppv); } static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface) { struct list_manager *This = impl_from_IConnectionPointContainer( iface ); return INetworkListManager_AddRef(&This->INetworkListManager_iface); } static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface) { struct list_manager *This = impl_from_IConnectionPointContainer( iface ); return INetworkListManager_Release(&This->INetworkListManager_iface); } static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface, IEnumConnectionPoints **ppEnum) { struct list_manager *This = impl_from_IConnectionPointContainer( iface ); FIXME("(%p)->(%p): stub\n", This, ppEnum); return E_NOTIMPL; } static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface, REFIID riid, IConnectionPoint **cp) { struct list_manager *This = impl_from_IConnectionPointContainer( iface ); struct connection_point *ret; TRACE( "%p, %s, %p\n", This, debugstr_guid(riid), cp ); if (!riid || !cp) return E_POINTER; if (IsEqualGUID( riid, &IID_INetworkListManagerEvents )) ret = &This->list_mgr_cp; else if (IsEqualGUID( riid, &IID_INetworkCostManagerEvents )) ret = &This->cost_mgr_cp; else if (IsEqualGUID( riid, &IID_INetworkConnectionEvents )) ret = &This->conn_mgr_cp; else if (IsEqualGUID( riid, &IID_INetworkEvents)) ret = &This->events_cp; else { FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); *cp = NULL; return E_NOINTERFACE; } IConnectionPoint_AddRef( *cp = &ret->IConnectionPoint_iface ); return S_OK; } static const struct IConnectionPointContainerVtbl cpc_vtbl = { ConnectionPointContainer_QueryInterface, ConnectionPointContainer_AddRef, ConnectionPointContainer_Release, ConnectionPointContainer_EnumConnectionPoints, ConnectionPointContainer_FindConnectionPoint }; static inline struct connection *impl_from_INetworkConnection( INetworkConnection *iface ) { return CONTAINING_RECORD( iface, struct connection, INetworkConnection_iface ); } static HRESULT WINAPI connection_QueryInterface( INetworkConnection *iface, REFIID riid, void **obj ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p, %s, %p\n", connection, debugstr_guid(riid), obj ); if (IsEqualIID( riid, &IID_INetworkConnection ) || IsEqualIID( riid, &IID_IDispatch ) || IsEqualIID( riid, &IID_IUnknown )) { *obj = iface; } else if (IsEqualIID( riid, &IID_INetworkConnectionCost )) { *obj = &connection->INetworkConnectionCost_iface; } else { WARN( "interface not supported %s\n", debugstr_guid(riid) ); *obj = NULL; return E_NOINTERFACE; } INetworkConnection_AddRef( iface ); return S_OK; } static ULONG WINAPI connection_AddRef( INetworkConnection *iface ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p\n", connection ); return InterlockedIncrement( &connection->refs ); } static ULONG WINAPI connection_Release( INetworkConnection *iface ) { struct connection *connection = impl_from_INetworkConnection( iface ); LONG refs; TRACE( "%p\n", connection ); if (!(refs = InterlockedDecrement( &connection->refs ))) { INetwork_Release( connection->network ); list_remove( &connection->entry ); heap_free( connection ); } return refs; } static HRESULT WINAPI connection_GetTypeInfoCount( INetworkConnection *iface, UINT *count ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connection_GetTypeInfo( INetworkConnection *iface, UINT index, LCID lcid, ITypeInfo **info ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connection_GetIDsOfNames( INetworkConnection *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *dispid ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connection_Invoke( INetworkConnection *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) { FIXME("\n"); return E_NOTIMPL; } static HRESULT WINAPI connection_GetNetwork( INetworkConnection *iface, INetwork **ppNetwork ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p, %p\n", iface, ppNetwork ); *ppNetwork = connection->network; INetwork_AddRef( *ppNetwork ); return S_OK; } static HRESULT WINAPI connection_get_IsConnectedToInternet( INetworkConnection *iface, VARIANT_BOOL *pbIsConnected ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p, %p\n", iface, pbIsConnected ); *pbIsConnected = connection->connected_to_internet; return S_OK; } static HRESULT WINAPI connection_get_IsConnected( INetworkConnection *iface, VARIANT_BOOL *pbIsConnected ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p, %p\n", iface, pbIsConnected ); *pbIsConnected = connection->connected; return S_OK; } static HRESULT WINAPI connection_GetConnectivity( INetworkConnection *iface, NLM_CONNECTIVITY *pConnectivity ) { FIXME( "%p, %p\n", iface, pConnectivity ); *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET; return S_OK; } static HRESULT WINAPI connection_GetConnectionId( INetworkConnection *iface, GUID *pgdConnectionId ) { struct connection *connection = impl_from_INetworkConnection( iface ); TRACE( "%p, %p\n", iface, pgdConnectionId ); *pgdConnectionId = connection->id; return S_OK; } static HRESULT WINAPI connection_GetAdapterId( INetworkConnection *iface, GUID *pgdAdapterId ) { struct connection *connection = impl_from_INetworkConnection( iface ); FIXME( "%p, %p\n", iface, pgdAdapterId ); *pgdAdapterId = connection->id; return S_OK; } static HRESULT WINAPI connection_GetDomainType( INetworkConnection *iface, NLM_DOMAIN_TYPE *pDomainType ) { FIXME( "%p, %p\n", iface, pDomainType ); *pDomainType = NLM_DOMAIN_TYPE_NON_DOMAIN_NETWORK; return S_OK; } static const struct INetworkConnectionVtbl connection_vtbl = { connection_QueryInterface, connection_AddRef, connection_Release, connection_GetTypeInfoCount, connection_GetTypeInfo, connection_GetIDsOfNames, connection_Invoke, connection_GetNetwork, connection_get_IsConnectedToInternet, connection_get_IsConnected, connection_GetConnectivity, connection_GetConnectionId, connection_GetAdapterId, connection_GetDomainType }; static inline struct connection *impl_from_INetworkConnectionCost( INetworkConnectionCost *iface ) { return CONTAINING_RECORD( iface, struct connection, INetworkConnectionCost_iface ); } static HRESULT WINAPI connection_cost_QueryInterface( INetworkConnectionCost *iface, REFIID riid, void **obj ) { struct connection *conn = impl_from_INetworkConnectionCost( iface ); return INetworkConnection_QueryInterface( &conn->INetworkConnection_iface, riid, obj ); } static ULONG WINAPI connection_cost_AddRef( INetworkConnectionCost *iface ) { struct connection *conn = impl_from_INetworkConnectionCost( iface ); return INetworkConnection_AddRef( &conn->INetworkConnection_iface ); } static ULONG WINAPI connection_cost_Release( INetworkConnectionCost *iface ) { struct connection *conn = impl_from_INetworkConnectionCost( iface ); return INetworkConnection_Release( &conn->INetworkConnection_iface ); } static HRESULT WINAPI connection_cost_GetCost( INetworkConnectionCost *iface, DWORD *pCost ) { FIXME( "%p, %p\n", iface, pCost ); if (!pCost) return E_POINTER; *pCost = NLM_CONNECTION_COST_UNRESTRICTED; return S_OK; } static HRESULT WINAPI connection_cost_GetDataPlanStatus( INetworkConnectionCost *iface, NLM_DATAPLAN_STATUS *pDataPlanStatus ) { struct connection *conn = impl_from_INetworkConnectionCost( iface ); FIXME( "%p, %p\n", iface, pDataPlanStatus ); if (!pDataPlanStatus) return E_POINTER; memcpy( &pDataPlanStatus->InterfaceGuid, &conn->id, sizeof(conn->id) ); pDataPlanStatus->UsageData.UsageInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; memset( &pDataPlanStatus->UsageData.LastSyncTime, 0, sizeof(pDataPlanStatus->UsageData.LastSyncTime) ); pDataPlanStatus->DataLimitInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->InboundBandwidthInKbps = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->OutboundBandwidthInKbps = NLM_UNKNOWN_DATAPLAN_STATUS; memset( &pDataPlanStatus->NextBillingCycle, 0, sizeof(pDataPlanStatus->NextBillingCycle) ); pDataPlanStatus->MaxTransferSizeInMegabytes = NLM_UNKNOWN_DATAPLAN_STATUS; pDataPlanStatus->Reserved = 0; return S_OK; } static const INetworkConnectionCostVtbl connection_cost_vtbl = { connection_cost_QueryInterface, connection_cost_AddRef, connection_cost_Release, connection_cost_GetCost, connection_cost_GetDataPlanStatus }; static struct connection *create_connection( const GUID *id ) { struct connection *ret; if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL; ret->INetworkConnection_iface.lpVtbl = &connection_vtbl; ret->INetworkConnectionCost_iface.lpVtbl = &connection_cost_vtbl; ret->refs = 1; ret->id = *id; ret->network = NULL; ret->connected = VARIANT_FALSE; ret->connected_to_internet = VARIANT_FALSE; list_init( &ret->entry ); return ret; } static void init_networks( struct list_manager *mgr ) { DWORD size = 0; IP_ADAPTER_ADDRESSES *buf, *aa; GUID id; ULONG ret, flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_ALL_GATEWAYS; list_init( &mgr->networks ); list_init( &mgr->connections ); ret = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, NULL, &size ); if (ret != ERROR_BUFFER_OVERFLOW) return; if (!(buf = heap_alloc( size ))) return; if (GetAdaptersAddresses( AF_UNSPEC, flags, NULL, buf, &size )) { heap_free( buf ); return; } memset( &id, 0, sizeof(id) ); for (aa = buf; aa; aa = aa->Next) { struct network *network; struct connection *connection; NET_LUID luid; ConvertInterfaceIndexToLuid(aa->u.s.IfIndex, &luid); ConvertInterfaceLuidToGuid(&luid, &id); /* assume a one-to-one mapping between networks and connections */ if (!(network = create_network( &id ))) goto done; if (!(connection = create_connection( &id ))) { INetwork_Release( &network->INetwork_iface ); goto done; } if (aa->FirstUnicastAddress) { network->connected = VARIANT_TRUE; connection->connected = VARIANT_TRUE; } if (aa->FirstGatewayAddress) { network->connected_to_internet = VARIANT_TRUE; connection->connected_to_internet = VARIANT_TRUE; } connection->network = &network->INetwork_iface; INetwork_AddRef( connection->network ); list_add_tail( &mgr->networks, &network->entry ); list_add_tail( &mgr->connections, &connection->entry ); } done: heap_free( buf ); } HRESULT list_manager_create( void **obj ) { struct list_manager *mgr; TRACE( "%p\n", obj ); if (!(mgr = heap_alloc( sizeof(*mgr) ))) return E_OUTOFMEMORY; mgr->INetworkListManager_iface.lpVtbl = &list_manager_vtbl; mgr->INetworkCostManager_iface.lpVtbl = &cost_manager_vtbl; mgr->IConnectionPointContainer_iface.lpVtbl = &cpc_vtbl; init_networks( mgr ); mgr->refs = 1; connection_point_init( &mgr->list_mgr_cp, &IID_INetworkListManagerEvents, &mgr->IConnectionPointContainer_iface ); connection_point_init( &mgr->cost_mgr_cp, &IID_INetworkCostManagerEvents, &mgr->IConnectionPointContainer_iface); connection_point_init( &mgr->conn_mgr_cp, &IID_INetworkConnectionEvents, &mgr->IConnectionPointContainer_iface ); connection_point_init( &mgr->events_cp, &IID_INetworkEvents, &mgr->IConnectionPointContainer_iface ); *obj = &mgr->INetworkListManager_iface; TRACE( "returning iface %p\n", *obj ); return S_OK; }