dlls/netprofm/list.c

   1 /*
   2  * Copyright 2014 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include <stdarg.h>
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #define COBJMACROS
  24 #include "initguid.h"
  25 #include "objbase.h"
  26 #include "netlistmgr.h"
  27
  28 #include "wine/debug.h"
  29 #include "netprofm_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(netprofm);
  32
  33 struct list_manager
  34 {
  35     INetworkListManager INetworkListManager_iface;
  36     INetworkCostManager INetworkCostManager_iface;
  37     LONG                refs;
  38 };
  39
  40 static inline struct list_manager *impl_from_INetworkCostManager(
  41     INetworkCostManager *iface )
  42 {
  43     return CONTAINING_RECORD( iface, struct list_manager, INetworkCostManager_iface );
  44 }
  45
  46 static HRESULT WINAPI cost_manager_QueryInterface(
  47     INetworkCostManager *iface,
  48     REFIID riid,
  49     void **obj )
  50 {
  51     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
  52     return INetworkListManager_QueryInterface( &mgr->INetworkListManager_iface, riid, obj );
  53 }
  54
  55 static ULONG WINAPI cost_manager_AddRef(
  56     INetworkCostManager *iface )
  57 {
  58     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
  59     return INetworkListManager_AddRef( &mgr->INetworkListManager_iface );
  60 }
  61
  62 static ULONG WINAPI cost_manager_Release(
  63     INetworkCostManager *iface )
  64 {
  65     struct list_manager *mgr = impl_from_INetworkCostManager( iface );
  66     return INetworkListManager_Release( &mgr->INetworkListManager_iface );
  67 }
  68
  69 static HRESULT WINAPI cost_manager_GetCost(
  70     INetworkCostManager *iface, DWORD *pCost, NLM_SOCKADDR *pDestIPAddr)
  71 {
  72     FIXME( "%p, %p, %p\n", iface, pCost, pDestIPAddr );
  73
  74     if (!pCost) return E_POINTER;
  75
  76     *pCost = NLM_CONNECTION_COST_UNRESTRICTED;
  77     return S_OK;
  78 }
  79
  80 static HRESULT WINAPI cost_manager_GetDataPlanStatus(
  81     INetworkCostManager *iface, NLM_DATAPLAN_STATUS *pDataPlanStatus,
  82     NLM_SOCKADDR *pDestIPAddr)
  83 {
  84     FIXME( "%p, %p, %p\n", iface, pDataPlanStatus, pDestIPAddr );
  85     return E_NOTIMPL;
  86 }
  87
  88 static HRESULT WINAPI cost_manager_SetDestinationAddresses(
  89     INetworkCostManager *iface, UINT32 length, NLM_SOCKADDR *pDestIPAddrList,
  90     VARIANT_BOOL bAppend)
  91 {
  92     FIXME( "%p, %u, %p, %x\n", iface, length, pDestIPAddrList, bAppend );
  93     return E_NOTIMPL;
  94 }
  95
  96 static const INetworkCostManagerVtbl cost_manager_vtbl =
  97 {
  98     cost_manager_QueryInterface,
  99     cost_manager_AddRef,
 100     cost_manager_Release,
 101     cost_manager_GetCost,
 102     cost_manager_GetDataPlanStatus,
 103     cost_manager_SetDestinationAddresses
 104 };
 105
 106 static inline struct list_manager *impl_from_INetworkListManager(
 107     INetworkListManager *iface )
 108 {
 109     return CONTAINING_RECORD( iface, struct list_manager, INetworkListManager_iface );
 110 }
 111
 112 static ULONG WINAPI list_manager_AddRef(
 113     INetworkListManager *iface )
 114 {
 115     struct list_manager *mgr = impl_from_INetworkListManager( iface );
 116     return InterlockedIncrement( &mgr->refs );
 117 }
 118
 119 static ULONG WINAPI list_manager_Release(
 120     INetworkListManager *iface )
 121 {
 122     struct list_manager *mgr = impl_from_INetworkListManager( iface );
 123     LONG refs = InterlockedDecrement( &mgr->refs );
 124     if (!refs)
 125     {
 126         TRACE( "destroying %p\n", mgr );
 127         HeapFree( GetProcessHeap(), 0, mgr );
 128     }
 129     return refs;
 130 }
 131
 132 static HRESULT WINAPI list_manager_QueryInterface(
 133     INetworkListManager *iface,
 134     REFIID riid,
 135     void **obj )
 136 {
 137     struct list_manager *mgr = impl_from_INetworkListManager( iface );
 138
 139     TRACE( "%p, %s, %p\n", mgr, debugstr_guid(riid), obj );
 140
 141     if (IsEqualGUID( riid, &IID_INetworkListManager ) ||
 142         IsEqualGUID( riid, &IID_IUnknown ))
 143     {
 144         *obj = iface;
 145     }
 146     else if (IsEqualGUID( riid, &IID_INetworkCostManager ))
 147     {
 148         *obj = &mgr->INetworkCostManager_iface;
 149     }
 150     else
 151     {
 152         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 153         return E_NOINTERFACE;
 154     }
 155     INetworkListManager_AddRef( iface );
 156     return S_OK;
 157 }
 158
 159 static HRESULT WINAPI list_manager_GetTypeInfoCount(
 160     INetworkListManager *iface,
 161     UINT *count )
 162 {
 163     FIXME("\n");
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI list_manager_GetTypeInfo(
 168     INetworkListManager *iface,
 169     UINT index,
 170     LCID lcid,
 171     ITypeInfo **info )
 172 {
 173     FIXME("\n");
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI list_manager_GetIDsOfNames(
 178     INetworkListManager *iface,
 179     REFIID riid,
 180     LPOLESTR *names,
 181     UINT count,
 182     LCID lcid,
 183     DISPID *dispid )
 184 {
 185     FIXME("\n");
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI list_manager_Invoke(
 190     INetworkListManager *iface,
 191     DISPID member,
 192     REFIID riid,
 193     LCID lcid,
 194     WORD flags,
 195     DISPPARAMS *params,
 196     VARIANT *result,
 197     EXCEPINFO *excep_info,
 198     UINT *arg_err )
 199 {
 200     FIXME("\n");
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI list_manager_GetNetworks(
 205     INetworkListManager *iface,
 206     NLM_ENUM_NETWORK Flags,
 207     IEnumNetworks **ppEnumNetwork )
 208 {
 209     FIXME( "%p, %x, %p\n", iface, Flags, ppEnumNetwork );
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI list_manager_GetNetwork(
 214     INetworkListManager *iface,
 215     GUID gdNetworkId,
 216     INetwork **ppNetwork )
 217 {
 218     FIXME( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkId), ppNetwork );
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI list_manager_GetNetworkConnections(
 223     INetworkListManager *iface,
 224     IEnumNetworkConnections **ppEnum )
 225 {
 226     FIXME( "%p, %p\n", iface, ppEnum );
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI list_manager_GetNetworkConnection(
 231     INetworkListManager *iface,
 232     GUID gdNetworkConnectionId,
 233     INetworkConnection **ppNetworkConnection )
 234 {
 235     FIXME( "%p, %s, %p\n", iface, debugstr_guid(&gdNetworkConnectionId),
 236             ppNetworkConnection );
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI list_manager_IsConnectedToInternet(
 241     INetworkListManager *iface,
 242     VARIANT_BOOL *pbIsConnected )
 243 {
 244     FIXME( "%p, %p\n", iface, pbIsConnected );
 245
 246     *pbIsConnected = VARIANT_TRUE;
 247     return S_OK;
 248 }
 249
 250 static HRESULT WINAPI list_manager_IsConnected(
 251     INetworkListManager *iface,
 252     VARIANT_BOOL *pbIsConnected )
 253 {
 254     FIXME( "%p, %p\n", iface, pbIsConnected );
 255
 256     *pbIsConnected = VARIANT_TRUE;
 257     return S_OK;
 258 }
 259
 260 static HRESULT WINAPI list_manager_GetConnectivity(
 261     INetworkListManager *iface,
 262     NLM_CONNECTIVITY *pConnectivity )
 263 {
 264     FIXME( "%p, %p\n", iface, pConnectivity );
 265
 266     *pConnectivity = NLM_CONNECTIVITY_IPV4_INTERNET;
 267     return S_OK;
 268 }
 269
 270 static const INetworkListManagerVtbl list_manager_vtbl =
 271 {
 272     list_manager_QueryInterface,
 273     list_manager_AddRef,
 274     list_manager_Release,
 275     list_manager_GetTypeInfoCount,
 276     list_manager_GetTypeInfo,
 277     list_manager_GetIDsOfNames,
 278     list_manager_Invoke,
 279     list_manager_GetNetworks,
 280     list_manager_GetNetwork,
 281     list_manager_GetNetworkConnections,
 282     list_manager_GetNetworkConnection,
 283     list_manager_IsConnectedToInternet,
 284     list_manager_IsConnected,
 285     list_manager_GetConnectivity
 286 };
 287
 288 HRESULT list_manager_create( void **obj )
 289 {
 290     struct list_manager *mgr;
 291
 292     TRACE( "%p\n", obj );
 293
 294     if (!(mgr = HeapAlloc( GetProcessHeap(), 0, sizeof(*mgr) ))) return E_OUTOFMEMORY;
 295     mgr->INetworkListManager_iface.lpVtbl = &list_manager_vtbl;
 296     mgr->INetworkCostManager_iface.lpVtbl = &cost_manager_vtbl;
 297     mgr->refs = 1;
 298
 299     *obj = &mgr->INetworkListManager_iface;
 300     TRACE( "returning iface %p\n", *obj );
 301     return S_OK;
 302 }