You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
391 lines
9.0 KiB
391 lines
9.0 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997 - 2000
|
|
//
|
|
// File: H N A P I E N . C P P
|
|
//
|
|
// Contents: OEM API
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: billi 21 Nov 2000
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
/*++
|
|
|
|
CNetSharingManager::EnumEveryConnections
|
|
|
|
Routine Description:
|
|
|
|
Return an IEnumNetEveryConnection interface used to enumerate all of
|
|
the contained INetConnections configured as a public adapter
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
STDMETHODIMP
|
|
CNetSharingManager::get_EnumEveryConnection(
|
|
INetSharingEveryConnectionCollection** ppColl)
|
|
{
|
|
HNET_OEM_API_ENTER
|
|
|
|
IEnumNetSharingEveryConnection * pENEC = NULL;
|
|
// idea: use existing code below to fill out pENPC,
|
|
// then convert to collection
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( NULL == ppColl )
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else if ( !IsSecureContext() )
|
|
{
|
|
*ppColl = NULL;
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
else
|
|
{
|
|
*ppColl = NULL;
|
|
|
|
INetConnectionManager* pManager = NULL;
|
|
|
|
hr = CoCreateInstance( CLSID_ConnectionManager,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
IID_PPV_ARG(INetConnectionManager, &pManager) );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
IEnumNetConnection* pNetEnum = NULL;
|
|
|
|
SetProxyBlanket(pManager);
|
|
|
|
hr = pManager->EnumConnections(NCME_DEFAULT, &pNetEnum);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
CComObject<CSharingManagerEnumEveryConnection>* pEnum;
|
|
|
|
hr = CComObject<CSharingManagerEnumEveryConnection>::CreateInstance(&pEnum);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
pEnum->AddRef();
|
|
|
|
hr = pEnum->Initialize( pNetEnum, ICSSC_DEFAULT );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = pEnum->QueryInterface(
|
|
IID_PPV_ARG(IEnumNetSharingEveryConnection, &pENEC)
|
|
);
|
|
}
|
|
|
|
ReleaseObj(pEnum);
|
|
}
|
|
|
|
ReleaseObj(pNetEnum);
|
|
}
|
|
|
|
ReleaseObj(pManager);
|
|
}
|
|
}
|
|
|
|
// create collection:
|
|
if (pENEC) {
|
|
if (hr == S_OK) {
|
|
CComObject<CNetSharingEveryConnectionCollection>* pNECC = NULL;
|
|
hr = CComObject<CNetSharingEveryConnectionCollection>::CreateInstance (&pNECC);
|
|
if (pNECC) {
|
|
pNECC->AddRef();
|
|
pNECC->Initialize (pENEC);
|
|
hr = pNECC->QueryInterface (__uuidof(INetSharingEveryConnectionCollection), (void**)ppColl);
|
|
pNECC->Release();
|
|
}
|
|
}
|
|
pENEC->Release();
|
|
}
|
|
|
|
return hr;
|
|
|
|
HNET_OEM_API_LEAVE
|
|
}
|
|
|
|
/*++
|
|
|
|
CNetSharingManager::EnumPublicConnections
|
|
|
|
Routine Description:
|
|
|
|
Return an IEnumNetPublicConnection interface used to enumerate all of
|
|
the contained INetConnections configured as a public adapter
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
STDMETHODIMP
|
|
CNetSharingManager::get_EnumPublicConnections(
|
|
SHARINGCONNECTION_ENUM_FLAGS Flags,
|
|
// IEnumNetPublicConnection** ppEnum
|
|
INetSharingPublicConnectionCollection** ppColl)
|
|
{
|
|
HNET_OEM_API_ENTER
|
|
|
|
IEnumNetSharingPublicConnection * pENPC = NULL;
|
|
// idea: use existing code below to fill out pENPC,
|
|
// then convert to collection
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( NULL == ppColl )
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else if ( !IsSecureContext() )
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
else
|
|
{
|
|
IEnumHNetIcsPublicConnections* pHNetEnum;
|
|
|
|
hr = m_pIcsSettings->EnumIcsPublicConnections( &pHNetEnum );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
CComObject<CSharingManagerEnumPublicConnection>* pEnum;
|
|
|
|
hr = CComObject<CSharingManagerEnumPublicConnection>::CreateInstance(&pEnum);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
pEnum->AddRef();
|
|
|
|
hr = pEnum->Initialize( pHNetEnum, Flags );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = pEnum->QueryInterface(
|
|
IID_PPV_ARG(IEnumNetSharingPublicConnection, &pENPC)
|
|
);
|
|
}
|
|
|
|
ReleaseObj(pEnum);
|
|
}
|
|
|
|
ReleaseObj(pHNetEnum);
|
|
}
|
|
}
|
|
|
|
// create collection:
|
|
if (pENPC) {
|
|
if (hr == S_OK) {
|
|
CComObject<CNetSharingPublicConnectionCollection>* pNPCC = NULL;
|
|
hr = CComObject<CNetSharingPublicConnectionCollection>::CreateInstance (&pNPCC);
|
|
if (pNPCC) {
|
|
pNPCC->AddRef();
|
|
pNPCC->Initialize (pENPC);
|
|
hr = pNPCC->QueryInterface (__uuidof(INetSharingPublicConnectionCollection), (void**)ppColl);
|
|
pNPCC->Release();
|
|
}
|
|
}
|
|
pENPC->Release();
|
|
}
|
|
|
|
return hr;
|
|
|
|
HNET_OEM_API_LEAVE
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
CNetSharingManager::EnumPrivateConnections
|
|
|
|
Routine Description:
|
|
|
|
Return an IEnumNetPrivateConnection interface used to enumerate all of
|
|
the contained INetConnections configured as a private adapter
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
STDMETHODIMP
|
|
CNetSharingManager::get_EnumPrivateConnections(
|
|
SHARINGCONNECTION_ENUM_FLAGS Flags,
|
|
// IEnumNetPrivateConnection** ppEnum)
|
|
INetSharingPrivateConnectionCollection** ppColl)
|
|
{
|
|
HNET_OEM_API_ENTER
|
|
|
|
IEnumNetSharingPrivateConnection * pENPC = NULL;
|
|
// idea: use existing code below to fill out pENPC,
|
|
// then convert to collection
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( NULL == ppColl )
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else if ( !IsSecureContext() )
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
else
|
|
{
|
|
IEnumHNetIcsPrivateConnections* pHNetEnum;
|
|
|
|
hr = m_pIcsSettings->EnumIcsPrivateConnections( &pHNetEnum );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
CComObject<CSharingManagerEnumPrivateConnection>* pEnum;
|
|
|
|
hr = CComObject<CSharingManagerEnumPrivateConnection>::CreateInstance(&pEnum);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
pEnum->AddRef();
|
|
|
|
hr = pEnum->Initialize( pHNetEnum, Flags );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = pEnum->QueryInterface(
|
|
IID_PPV_ARG(IEnumNetSharingPrivateConnection, &pENPC)
|
|
);
|
|
}
|
|
|
|
ReleaseObj(pEnum);
|
|
}
|
|
|
|
ReleaseObj(pHNetEnum);
|
|
}
|
|
}
|
|
|
|
// create collection:
|
|
if (pENPC) {
|
|
if (hr == S_OK) {
|
|
CComObject<CNetSharingPrivateConnectionCollection>* pNPCC = NULL;
|
|
hr = CComObject<CNetSharingPrivateConnectionCollection>::CreateInstance (&pNPCC);
|
|
if (pNPCC) {
|
|
pNPCC->AddRef();
|
|
pNPCC->Initialize (pENPC);
|
|
hr = pNPCC->QueryInterface (__uuidof(INetSharingPrivateConnectionCollection), (void**)ppColl);
|
|
pNPCC->Release();
|
|
}
|
|
}
|
|
pENPC->Release();
|
|
}
|
|
|
|
return hr;
|
|
|
|
HNET_OEM_API_LEAVE
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CNetSharingConfiguration::get_EnumPortMappings(
|
|
SHARINGCONNECTION_ENUM_FLAGS Flags,
|
|
// IEnumSharingPortMapping** ppEnum)
|
|
INetSharingPortMappingCollection** ppColl)
|
|
{
|
|
HNET_OEM_API_ENTER
|
|
|
|
IEnumNetSharingPortMapping * pESPM = NULL;
|
|
// idea: use existing code below to fill out pESPM,
|
|
// then convert to collection
|
|
HRESULT hr = S_OK;
|
|
|
|
IHNetProtocolSettings *pProtocolSettings;
|
|
|
|
if ( NULL == ppColl )
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else if ( !IsSecureContext() )
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
else if ( NULL == m_pHNetConnection )
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
IEnumHNetPortMappingBindings *pHNetEnum;
|
|
|
|
hr = m_pHNetConnection->EnumPortMappings( Flags & ICSSC_ENABLED, &pHNetEnum );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
CComObject<CSharingManagerEnumPortMapping>* pEnum;
|
|
|
|
hr = CComObject<CSharingManagerEnumPortMapping>::CreateInstance(&pEnum);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
pEnum->AddRef();
|
|
|
|
hr = pEnum->Initialize( pHNetEnum, Flags );
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = pEnum->QueryInterface(
|
|
IID_PPV_ARG(IEnumNetSharingPortMapping, &pESPM)
|
|
);
|
|
}
|
|
|
|
ReleaseObj(pEnum);
|
|
}
|
|
|
|
ReleaseObj(pHNetEnum);
|
|
}
|
|
}
|
|
|
|
// create collection:
|
|
if (pESPM) {
|
|
if (hr == S_OK) {
|
|
CComObject<CNetSharingPortMappingCollection>* pNPCC = NULL;
|
|
hr = CComObject<CNetSharingPortMappingCollection>::CreateInstance (&pNPCC);
|
|
if (pNPCC) {
|
|
pNPCC->AddRef();
|
|
pNPCC->Initialize (pESPM);
|
|
hr = pNPCC->QueryInterface (__uuidof(INetSharingPortMappingCollection), (void**)ppColl);
|
|
pNPCC->Release();
|
|
}
|
|
}
|
|
pESPM->Release();
|
|
}
|
|
|
|
return hr;
|
|
|
|
HNET_OEM_API_LEAVE
|
|
}
|