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.
1075 lines
30 KiB
1075 lines
30 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: N C R A S . C P P
|
|
//
|
|
// Contents: Common code for RAS connections.
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: shaunco 20 Oct 1997
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include "ncnetcon.h"
|
|
#include "ncras.h"
|
|
#include "ncstring.h"
|
|
#include <raserror.h>
|
|
#include "mprapi.h"
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: RciFree
|
|
//
|
|
// Purpose: Frees the memory associated with a RASCON_INFO strucutre.
|
|
//
|
|
// Arguments:
|
|
// pRasConInfo [in] Pointer to RASCON_INFO structure to free.
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
// Author: shaunco 21 Sep 1997
|
|
//
|
|
// Notes: CoTaskMemAlloc/CoTaskMemFree are used as the allocator/
|
|
// deallocator because this structure is marshalled by COM.
|
|
//
|
|
VOID
|
|
RciFree (
|
|
RASCON_INFO* pRasConInfo)
|
|
{
|
|
Assert (pRasConInfo);
|
|
|
|
CoTaskMemFree (pRasConInfo->pszwPbkFile);
|
|
CoTaskMemFree (pRasConInfo->pszwEntryName);
|
|
|
|
ZeroMemory (pRasConInfo, sizeof (*pRasConInfo));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FExistActiveRasConnections
|
|
//
|
|
// Purpose: Returns TRUE if there is at least one active RAS connection.
|
|
// Both incoming and outgoing connections are checked.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: TRUE if at least one incoming or outgoing RAS connection
|
|
// in progress. FALSE if not.
|
|
//
|
|
// Author: shaunco 8 Jul 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL
|
|
FExistActiveRasConnections ()
|
|
{
|
|
BOOL fExist = FALSE;
|
|
RASCONN RasConn;
|
|
DWORD dwErr;
|
|
DWORD cbBuf;
|
|
DWORD cConnections;
|
|
|
|
ZeroMemory (&RasConn, sizeof(RasConn));
|
|
RasConn.dwSize = sizeof(RasConn);
|
|
cbBuf = sizeof(RasConn);
|
|
cConnections = 0;
|
|
dwErr = RasEnumConnections (&RasConn, &cbBuf, &cConnections);
|
|
if ((ERROR_SUCCESS == dwErr) || (ERROR_BUFFER_TOO_SMALL == dwErr))
|
|
{
|
|
fExist = (cbBuf > 0) || (cConnections > 0);
|
|
}
|
|
|
|
// If no outgoing connections active, check on incoming ones.
|
|
//
|
|
if (!fExist)
|
|
{
|
|
MPR_SERVER_HANDLE hMprServer;
|
|
LPBYTE lpbBuf = NULL;
|
|
DWORD dwEntriesRead = 0;
|
|
DWORD dwTotalEntries = 0;
|
|
|
|
ZeroMemory (&hMprServer, sizeof(hMprServer));
|
|
//get a handle to the local router ie. name = NULL
|
|
dwErr = MprAdminServerConnect( NULL, &hMprServer );
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
//retrieve a pointer to buffer containing all
|
|
//incoming connections (ie dwPrefMaxLen = -1) and
|
|
//the their count ( ie. dwTotalEntries )
|
|
dwErr = MprAdminConnectionEnum( hMprServer,
|
|
0,
|
|
&lpbBuf,
|
|
(DWORD)-1,
|
|
&dwEntriesRead,
|
|
&dwTotalEntries,
|
|
NULL );
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
fExist = (dwTotalEntries > 0);
|
|
if( lpbBuf )
|
|
{
|
|
MprAdminBufferFree( lpbBuf );
|
|
lpbBuf = NULL;
|
|
}
|
|
}
|
|
// close the handle to the router
|
|
MprAdminServerDisconnect( hMprServer );
|
|
}
|
|
}
|
|
|
|
return fExist;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRciGetRasConnectionInfo
|
|
//
|
|
// Purpose: QI an INetConnection pointer for INetRasConnection and make
|
|
// a call to GetRasConnectionInfo on it.
|
|
//
|
|
// Arguments:
|
|
// pCon [in] The connection to QI and call.
|
|
// pRasConInfo [out] The returned information.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 15 Nov 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRciGetRasConnectionInfo (
|
|
INetConnection* pCon,
|
|
RASCON_INFO* pRasConInfo)
|
|
{
|
|
INetRasConnection* pRasCon;
|
|
HRESULT hr = HrQIAndSetProxyBlanket(pCon, &pRasCon);
|
|
if (S_OK == hr)
|
|
{
|
|
// Make the call to get the info and release the interface.
|
|
//
|
|
hr = pRasCon->GetRasConnectionInfo (pRasConInfo);
|
|
|
|
ReleaseObj (pRasCon);
|
|
}
|
|
TraceError ("HrRciGetRasConnectionInfo", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasEnumAllActiveConnections
|
|
//
|
|
// Purpose: Enumerate and return all active RAS connections.
|
|
//
|
|
// Arguments:
|
|
// paRasConn [out] Pointer to returned allocation of RASCONN structures.
|
|
// pcRasConn [out] Pointer to count of RASCONN structures returned.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 23 Sep 1997
|
|
//
|
|
// Notes: The returned buffer must be freed using free.
|
|
//
|
|
HRESULT
|
|
HrRasEnumAllActiveConnections (
|
|
RASCONN** paRasConn,
|
|
DWORD* pcRasConn)
|
|
{
|
|
// Allocate room for two active connections initially. We'll update
|
|
// this guess after we successfully allocate and find out how much was
|
|
// really needed. Saving it across calls will keep us from allocating
|
|
// too much or too little.
|
|
//
|
|
static DWORD cbBufGuess = 2 * sizeof (RASCONN);
|
|
|
|
DWORD cbBuf = cbBufGuess;
|
|
BOOL fRetry = TRUE;
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
*paRasConn = NULL;
|
|
*pcRasConn = NULL;
|
|
|
|
// Allocate cbBuf bytes.
|
|
//
|
|
allocate:
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
RASCONN* aRasConn = reinterpret_cast<RASCONN*>(MemAlloc (cbBuf));
|
|
if (aRasConn)
|
|
{
|
|
aRasConn->dwSize = sizeof (RASCONN);
|
|
|
|
DWORD cRasConn;
|
|
DWORD dwErr = RasEnumConnections (aRasConn, &cbBuf, &cRasConn);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Update our guess for next time to be one more than we got back
|
|
// this time.
|
|
//
|
|
cbBufGuess = cbBuf + sizeof (RASCONN);
|
|
|
|
if (cRasConn)
|
|
{
|
|
*paRasConn = aRasConn;
|
|
*pcRasConn = cRasConn;
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasConn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasConn);
|
|
|
|
if (ERROR_BUFFER_TOO_SMALL == dwErr)
|
|
{
|
|
TraceTag (ttidWanCon, "Perf: Guessed buffer size incorrectly "
|
|
"calling RasEnumConnections.\n"
|
|
" Guessed %d, needed %d.", cbBufGuess, cbBuf);
|
|
|
|
// In case RAS makes more calls by the time we get back
|
|
// to enumerate with the bigger buffer, add room for a few
|
|
// more.
|
|
//
|
|
cbBuf += 2 * sizeof (RASCONN);
|
|
|
|
// Protect from an infinte loop by only retrying once.
|
|
//
|
|
if (fRetry)
|
|
{
|
|
fRetry = FALSE;
|
|
goto allocate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError ("HrRasEnumAllActiveConnections", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasEnumAllActiveServerConnections
|
|
//
|
|
// Purpose: Enumerate and return all active RAS server connections.
|
|
//
|
|
// Arguments:
|
|
// paRasSrvConn [out] Pointer to returned allocation of RASSRVCONN
|
|
// structures.
|
|
// pcRasSrvConn [out] Pointer to count of RASSRVCONN structures
|
|
// returned.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 12 Nov 1997
|
|
//
|
|
// Notes: The returned buffer must be freed using free.
|
|
//
|
|
HRESULT
|
|
HrRasEnumAllActiveServerConnections (
|
|
RASSRVCONN** paRasSrvConn,
|
|
DWORD* pcRasSrvConn)
|
|
{
|
|
// Allocate room for two active connections initially. We'll update
|
|
// this guess after we successfully allocate and find out how much was
|
|
// really needed. Saving it across calls will keep us from allocating
|
|
// too much or too little.
|
|
//
|
|
static DWORD cbBufGuess = 2 * sizeof (RASSRVCONN);
|
|
|
|
DWORD cbBuf = cbBufGuess;
|
|
BOOL fRetry = TRUE;
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
*paRasSrvConn = NULL;
|
|
*pcRasSrvConn = NULL;
|
|
|
|
// Allocate cbBuf bytes.
|
|
//
|
|
allocate:
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
RASSRVCONN* aRasSrvConn = reinterpret_cast<RASSRVCONN*>(MemAlloc (cbBuf));
|
|
if (aRasSrvConn)
|
|
{
|
|
aRasSrvConn->dwSize = sizeof (RASSRVCONN);
|
|
|
|
DWORD cRasSrvConn;
|
|
DWORD dwErr = RasSrvEnumConnections (aRasSrvConn, &cbBuf, &cRasSrvConn);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Update our guess for next time to be one more than we got back
|
|
// this time.
|
|
//
|
|
cbBufGuess = cbBuf + sizeof (RASSRVCONN);
|
|
|
|
if (cRasSrvConn)
|
|
{
|
|
*paRasSrvConn = aRasSrvConn;
|
|
*pcRasSrvConn = cRasSrvConn;
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasSrvConn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasSrvConn);
|
|
|
|
if (ERROR_BUFFER_TOO_SMALL == dwErr)
|
|
{
|
|
TraceTag (ttidWanCon, "Perf: Guessed buffer size incorrectly "
|
|
"calling RasSrvEnumConnections.\n"
|
|
" Guessed %d, needed %d.", cbBufGuess, cbBuf);
|
|
|
|
// In case RAS makes more calls by the time we get back
|
|
// to enumerate with the bigger buffer, add room for a few
|
|
// more.
|
|
//
|
|
cbBuf += 2 * sizeof (RASSRVCONN);
|
|
|
|
// Protect from an infinte loop by only retrying once.
|
|
//
|
|
if (fRetry)
|
|
{
|
|
fRetry = FALSE;
|
|
goto allocate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError ("HrRasEnumAllActiveServerConnections", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasEnumAllEntriesWithDetails
|
|
//
|
|
// Purpose: Enumerate and return all RAS entries in a phone book.
|
|
//
|
|
// Arguments:
|
|
// pszPhonebook [in] Phonebook file to use.
|
|
// paRasEntryDetails [out] Pointer to returned allocation of
|
|
// RASENUMENTRYDETAILS structures.
|
|
// pcRasEntryDetails [out] Pointer to count of RASENUMENTRYDETAILS
|
|
// structures returned.
|
|
//
|
|
// Returns: S_OK, S_FALSE if no entries, or an error code.
|
|
//
|
|
// Author: shaunco 2 Oct 1997
|
|
//
|
|
// Notes: The returned buffer must be freed using free.
|
|
//
|
|
HRESULT
|
|
HrRasEnumAllEntriesWithDetails (
|
|
PCWSTR pszPhonebook,
|
|
RASENUMENTRYDETAILS** paRasEntryDetails,
|
|
DWORD* pcRasEntryDetails)
|
|
{
|
|
// Allocate room for five entry names initially. We'll update
|
|
// this guess after we successfully allocate and find out how much was
|
|
// really needed. Saving it across calls will keep us from allocating
|
|
// too much or too little.
|
|
//
|
|
static DWORD cbBufGuess = 5 * sizeof (RASENUMENTRYDETAILS);
|
|
|
|
DWORD cbBuf = cbBufGuess;
|
|
BOOL fRetry = TRUE;
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
*paRasEntryDetails = NULL;
|
|
*pcRasEntryDetails = 0;
|
|
|
|
// Allocate cbBuf bytes.
|
|
//
|
|
allocate:
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
RASENUMENTRYDETAILS* aRasEntryDetails =
|
|
reinterpret_cast<RASENUMENTRYDETAILS*>(MemAlloc (cbBuf));
|
|
if (aRasEntryDetails)
|
|
{
|
|
ZeroMemory(aRasEntryDetails, cbBuf);
|
|
aRasEntryDetails->dwSize = sizeof (RASENUMENTRYDETAILS);
|
|
|
|
DWORD cRasEntryDetails;
|
|
DWORD dwErr = DwEnumEntryDetails (
|
|
pszPhonebook,
|
|
aRasEntryDetails,
|
|
&cbBuf, &cRasEntryDetails);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Update our guess for next time to be one more than we got back
|
|
// this time.
|
|
//
|
|
cbBufGuess = cbBuf + sizeof (RASENUMENTRYDETAILS);
|
|
|
|
if (cRasEntryDetails)
|
|
{
|
|
*paRasEntryDetails = aRasEntryDetails;
|
|
*pcRasEntryDetails = cRasEntryDetails;
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasEntryDetails);
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MemFree (aRasEntryDetails);
|
|
|
|
if (ERROR_BUFFER_TOO_SMALL == dwErr)
|
|
{
|
|
TraceTag (ttidWanCon, "Perf: Guessed buffer size incorrectly "
|
|
"calling DwEnumEntryDetails.\n"
|
|
" Guessed %d, needed %d.", cbBufGuess, cbBuf);
|
|
|
|
// Protect from an infinte loop by only retrying once.
|
|
//
|
|
if (fRetry)
|
|
{
|
|
fRetry = FALSE;
|
|
goto allocate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError ("HrRasEnumAllEntriesWithDetails", (S_FALSE == hr) ? S_OK : hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFindRasConnFromGuidId
|
|
//
|
|
// Purpose: Searches for the active RAS connection that corresponds to
|
|
// the phone book entry given by a GUID.
|
|
//
|
|
// Arguments:
|
|
// pguid [in] Pointer to the GUID which identifies the entry.
|
|
// phRasConn [out] The returned handle to the RAS connection if it
|
|
// was found. NULL otherwise.
|
|
// pRasConn [out] Optional pointer to returned RASCONN structure
|
|
// if found.
|
|
//
|
|
// Returns: S_OK if found, S_FALSE if not, or an error code.
|
|
//
|
|
// Author: shaunco 29 Sep 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrFindRasConnFromGuidId (
|
|
IN const GUID* pguid,
|
|
OUT HRASCONN* phRasConn,
|
|
OUT RASCONN* pRasConn OPTIONAL)
|
|
{
|
|
Assert (pguid);
|
|
Assert (phRasConn);
|
|
|
|
HRESULT hr;
|
|
RASCONN* aRasConn;
|
|
DWORD cRasConn;
|
|
|
|
// Initialize the output parameter.
|
|
//
|
|
*phRasConn = NULL;
|
|
|
|
hr = HrRasEnumAllActiveConnections (&aRasConn, &cRasConn);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = S_FALSE;
|
|
|
|
for (DWORD i = 0; i < cRasConn; i++)
|
|
{
|
|
if (*pguid == aRasConn[i].guidEntry)
|
|
{
|
|
*phRasConn = aRasConn[i].hrasconn;
|
|
|
|
if (pRasConn)
|
|
{
|
|
CopyMemory (pRasConn, &aRasConn[i], sizeof(RASCONN));
|
|
}
|
|
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
}
|
|
|
|
MemFree (aRasConn);
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, S_FALSE == hr, "HrFindRasConnFromGuidId");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasGetEntryProperties
|
|
//
|
|
// Purpose: Wrapper around RasGetEntryProperties that returns an HRESULT
|
|
// and allocates the necessary memory automatically.
|
|
//
|
|
// Arguments:
|
|
// pszPhonebook [in]
|
|
// pszEntry [in]
|
|
// ppRasEntry [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 6 Oct 1997
|
|
//
|
|
// Notes: The output parameters should be freed using free.
|
|
//
|
|
HRESULT
|
|
HrRasGetEntryProperties (
|
|
PCWSTR pszPhonebook,
|
|
PCWSTR pszEntry,
|
|
RASENTRY** ppRasEntry,
|
|
DWORD* pcbRasEntry)
|
|
{
|
|
// Init the output parameter if provided.
|
|
//
|
|
if (pcbRasEntry)
|
|
{
|
|
*pcbRasEntry = 0;
|
|
}
|
|
|
|
// Allocate room for RASENTRY structure plus 256 bytes initially.
|
|
// We'll update this guess after we successfully allocate and find out
|
|
// how much was really needed. Saving it across calls will keep us
|
|
// from allocating too much or too little.
|
|
//
|
|
static DWORD cbBufGuess = sizeof (RASENTRY) + 256;
|
|
|
|
DWORD cbBuf = cbBufGuess;
|
|
BOOL fRetry = TRUE;
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
*ppRasEntry = NULL;
|
|
if (pcbRasEntry)
|
|
{
|
|
*pcbRasEntry = 0;
|
|
}
|
|
|
|
// Allocate cbBuf bytes.
|
|
//
|
|
allocate:
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
RASENTRY* pRasEntry = reinterpret_cast<RASENTRY*>(MemAlloc (cbBuf));
|
|
if (pRasEntry)
|
|
{
|
|
pRasEntry->dwSize = sizeof (RASENTRY);
|
|
|
|
DWORD dwErr = RasGetEntryProperties (pszPhonebook, pszEntry,
|
|
pRasEntry, &cbBuf, NULL, NULL);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Update our guess for next time to be a bit more than we
|
|
// got back this time.
|
|
//
|
|
cbBufGuess = cbBuf + 256;
|
|
|
|
*ppRasEntry = pRasEntry;
|
|
if (pcbRasEntry)
|
|
{
|
|
*pcbRasEntry = cbBuf;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MemFree (pRasEntry);
|
|
|
|
if (ERROR_BUFFER_TOO_SMALL == dwErr)
|
|
{
|
|
TraceTag (ttidWanCon, "Perf: Guessed buffer size incorrectly "
|
|
"calling RasGetEntryProperties.\n"
|
|
" Guessed %d, needed %d.", cbBufGuess, cbBuf);
|
|
|
|
// Protect from an infinte loop by only retrying once.
|
|
//
|
|
if (fRetry)
|
|
{
|
|
fRetry = FALSE;
|
|
goto allocate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError ("HrRasGetEntryProperties", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasGetSubEntryProperties
|
|
//
|
|
// Purpose: Wrapper around RasGetSubEntryProperties that returns an HRESULT
|
|
// and allocates the necessary memory automatically.
|
|
//
|
|
// Arguments:
|
|
// pszPhonebook [in]
|
|
// pszEntry [in]
|
|
// dwSubEntry [in]
|
|
// ppRasSubEntry [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: CWill 02/10/98
|
|
//
|
|
// Notes: The output parameters should be freed using free.
|
|
//
|
|
HRESULT
|
|
HrRasGetSubEntryProperties (
|
|
PCWSTR pszPhonebook,
|
|
PCWSTR pszEntry,
|
|
DWORD dwSubEntry,
|
|
RASSUBENTRY** ppRasSubEntry)
|
|
{
|
|
// Allocate room for RASSUBENTRY structure plus 256 bytes initially.
|
|
// We'll update this guess after we successfully allocate and find out
|
|
// how much was really needed. Saving it across calls will keep us
|
|
// from allocating too much or too little.
|
|
//
|
|
static DWORD cbBufGuess = sizeof (RASSUBENTRY) + 256;
|
|
|
|
DWORD cbBuf = cbBufGuess;
|
|
BOOL fRetry = TRUE;
|
|
|
|
// Initialize the output parameters.
|
|
//
|
|
*ppRasSubEntry = NULL;
|
|
|
|
// Allocate cbBuf bytes.
|
|
//
|
|
allocate:
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
RASSUBENTRY* pRasSubEntry = reinterpret_cast<RASSUBENTRY*>(MemAlloc (cbBuf));
|
|
if (pRasSubEntry)
|
|
{
|
|
pRasSubEntry->dwSize = sizeof (RASSUBENTRY);
|
|
|
|
DWORD dwErr = RasGetSubEntryProperties (pszPhonebook, pszEntry,
|
|
dwSubEntry, pRasSubEntry, &cbBuf, NULL, NULL);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Update our guess for next time to be a bit more than we
|
|
// got back this time.
|
|
//
|
|
cbBufGuess = cbBuf + 256;
|
|
|
|
*ppRasSubEntry = pRasSubEntry;
|
|
}
|
|
else
|
|
{
|
|
MemFree (pRasSubEntry);
|
|
|
|
if (ERROR_BUFFER_TOO_SMALL == dwErr)
|
|
{
|
|
TraceTag (ttidWanCon, "Perf: Guessed buffer size incorrectly "
|
|
"calling RasGetSubEntryProperties.\n"
|
|
" Guessed %d, needed %d.", cbBufGuess, cbBuf);
|
|
|
|
// Protect from an infinte loop by only retrying once.
|
|
//
|
|
if (fRetry)
|
|
{
|
|
fRetry = FALSE;
|
|
goto allocate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError ("HrRasGetSubEntryProperties", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasGetNetconStatusFromRasConnectStatus
|
|
//
|
|
// Purpose: Returns a NETCON_STATUS value given a handle to a RAS
|
|
// connection by calling RasGetConnectStatus and mapping.
|
|
//
|
|
// Arguments:
|
|
// hRasConn [in] Handle to the RAS connection. (See Win32 RAS APIs.)
|
|
// pStatus [out] Pointer to where the NETCON_STATUS is returned.
|
|
//
|
|
// Returns: S_OK or an error code in the FACILITY_WIN32 facility.
|
|
//
|
|
// Author: shaunco 6 May 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRasGetNetconStatusFromRasConnectStatus (
|
|
HRASCONN hRasConn,
|
|
NETCON_STATUS* pStatus)
|
|
{
|
|
Assert (pStatus);
|
|
|
|
// Initialize the output parameter.
|
|
//
|
|
*pStatus = NCS_DISCONNECTED;
|
|
|
|
// Get its status and map it to our status.
|
|
//
|
|
RASCONNSTATUS RasConnStatus;
|
|
ZeroMemory (&RasConnStatus, sizeof(RasConnStatus));
|
|
RasConnStatus.dwSize = sizeof(RASCONNSTATUS);
|
|
|
|
DWORD dwErr = RasGetConnectStatus (hRasConn, &RasConnStatus);
|
|
|
|
HRESULT hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceHr (ttidError, FAL, hr,
|
|
(HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE) == hr),
|
|
"RasGetConnectStatus");
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
if (RasConnStatus.rasconnstate & RASCS_DONE)
|
|
{
|
|
if (RASCS_Disconnected != RasConnStatus.rasconnstate)
|
|
{
|
|
*pStatus = NCS_CONNECTED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*pStatus = NCS_CONNECTING;
|
|
}
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr,
|
|
(HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE) == hr),
|
|
"HrRasGetNetconStatusFromRasConnectStatus");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasHangupUntilDisconnected
|
|
//
|
|
// Purpose: Call RasHangup until the connection is disconnected.
|
|
// Ras reference-counts RasDial/RasHangup, so this is called
|
|
// when the connection needs to be dropped no matter what.
|
|
// (For example, the behavior of disconnect from the shell
|
|
// is to drop the connection regardless of who dialed it.)
|
|
//
|
|
// Arguments:
|
|
// hRasConn [in] The connection to disconnect.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 29 May 1999
|
|
//
|
|
HRESULT
|
|
HrRasHangupUntilDisconnected (
|
|
IN HRASCONN hRasConn)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
BOOL fDisconnectAgain;
|
|
do
|
|
{
|
|
fDisconnectAgain = FALSE;
|
|
|
|
// Hang up.
|
|
//
|
|
DWORD dwErr = RasHangUp (hRasConn);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceError ("RasHangUp", hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Since the connection may be ref-counted, see if
|
|
// it's still connected and, if it is, go back and
|
|
// disconnect again.
|
|
//
|
|
HRESULT hrT;
|
|
NETCON_STATUS Status;
|
|
|
|
hrT = HrRasGetNetconStatusFromRasConnectStatus (
|
|
hRasConn,
|
|
&Status);
|
|
|
|
if ((S_OK == hrT) && (NCS_CONNECTED == Status))
|
|
{
|
|
fDisconnectAgain = TRUE;
|
|
|
|
TraceTag (ttidWanCon, "need to disconnect again...");
|
|
}
|
|
}
|
|
} while (fDisconnectAgain);
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE, "HrRasHangupUntilDisconnected");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasNetConToSharedConnection
|
|
//
|
|
// Purpose: Converts an 'INetConnection' to the format expected
|
|
// by the RAS sharing API routines.
|
|
//
|
|
// Arguments:
|
|
// pCon [in]
|
|
// prcs [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: AboladeG 05/14/98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrNetConToSharedConnection (
|
|
INetConnection* pCon,
|
|
LPRASSHARECONN prsc)
|
|
{
|
|
HRESULT hr;
|
|
NETCON_PROPERTIES* pProps;
|
|
hr = pCon->GetProperties(&pProps);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pProps->MediaType == NCM_LAN)
|
|
{
|
|
RasGuidToSharedConnection(&pProps->guidId, prsc);
|
|
}
|
|
else
|
|
{
|
|
INetRasConnection* pnrc;
|
|
hr = HrQIAndSetProxyBlanket(pCon, &pnrc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
RASCON_INFO rci;
|
|
hr = pnrc->GetRasConnectionInfo (&rci);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
RasEntryToSharedConnection (
|
|
rci.pszwPbkFile, rci.pszwEntryName, prsc );
|
|
RciFree (&rci);
|
|
}
|
|
ReleaseObj (pnrc);
|
|
}
|
|
}
|
|
FreeNetconProperties(pProps);
|
|
}
|
|
TraceError ("HrRasNetConToSharedConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasIsSharedConnection
|
|
//
|
|
// Purpose: Wrapper around RasIsSharedConnection that returns an HRESULT.
|
|
//
|
|
// Arguments:
|
|
// prsc [in]
|
|
// pfShared [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: AboladeG 05/04/98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRasIsSharedConnection (
|
|
LPRASSHARECONN prsc,
|
|
BOOL* pfShared)
|
|
{
|
|
*pfShared = FALSE;
|
|
DWORD dwErr = RasIsSharedConnection (prsc, pfShared);
|
|
HRESULT hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceError ("HrRasIsSharedConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
#if 0
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasQueryLanConnTable
|
|
//
|
|
// Purpose: Wrapper around RasQueryLanConnTable that returns an HRESULT.
|
|
//
|
|
// Arguments:
|
|
// prsc [in]
|
|
// ppLanTable [out,optional]
|
|
// pdwLanCount [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: AboladeG 05/14/98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRasQueryLanConnTable (
|
|
LPRASSHARECONN prsc,
|
|
NETCON_PROPERTIES** ppLanTable,
|
|
LPDWORD pdwLanCount)
|
|
{
|
|
DWORD dwErr = RasQueryLanConnTable (prsc, (LPVOID*)ppLanTable, pdwLanCount);
|
|
HRESULT hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceError ("HrRasQueryLanConnTable", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasShareConnection
|
|
//
|
|
// Purpose: Wrapper around RasShareConnection that returns an HRESULT.
|
|
//
|
|
// Arguments:
|
|
// prsc [in]
|
|
// pPrivateLanGuid [in,optional]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: AboladeG 05/14/98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRasShareConnection (
|
|
LPRASSHARECONN prsc,
|
|
GUID* pPrivateLanGuid)
|
|
{
|
|
DWORD dwErr = RasShareConnection (prsc, pPrivateLanGuid);
|
|
HRESULT hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceError ("HrRasShareConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrRasUnshareConnection
|
|
//
|
|
// Purpose: Wrapper around HrRasUnshareConnection that returns an HRESULT.
|
|
//
|
|
// Arguments:
|
|
// pfWasShared [out]
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: AboladeG 05/14/98
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT
|
|
HrRasUnshareConnection (
|
|
PBOOL pfWasShared)
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwErr = RasUnshareConnection (pfWasShared);
|
|
hr = HRESULT_FROM_WIN32 (dwErr);
|
|
TraceError ("HrRasUnshareConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
#endif
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: RasSrvTypeFromRasDeviceType
|
|
//
|
|
// Purpose: Converts from RASDEVICETYPE into an accepted incoming type
|
|
//
|
|
// Arguments:
|
|
// rdt [in] the RasDeviceType
|
|
//
|
|
// Returns: RASSRVUI_Xxx type
|
|
//
|
|
// Author: ckotze 19 Apr 2001
|
|
//
|
|
// Notes:
|
|
//
|
|
DWORD RasSrvTypeFromRasDeviceType(RASDEVICETYPE rdt)
|
|
{
|
|
DWORD dwType = RASSRVUI_MODEM;
|
|
|
|
TraceTag (ttidWanCon, "rdt:0x%08x, dwType:0x%08x",
|
|
rdt,
|
|
dwType);
|
|
|
|
switch (LOWORD(rdt))
|
|
{
|
|
case RDT_PPPoE:
|
|
dwType = RASSRVUI_MODEM;
|
|
break;
|
|
|
|
case RDT_Modem:
|
|
case RDT_X25:
|
|
dwType = RASSRVUI_MODEM;
|
|
break;
|
|
|
|
case RDT_Isdn:
|
|
dwType = RASSRVUI_MODEM;
|
|
break;
|
|
|
|
case RDT_Serial:
|
|
case RDT_FrameRelay:
|
|
case RDT_Atm:
|
|
case RDT_Sonet:
|
|
case RDT_Sw56:
|
|
dwType = RASSRVUI_MODEM;
|
|
break;
|
|
|
|
case RDT_Tunnel_Pptp:
|
|
case RDT_Tunnel_L2tp:
|
|
dwType = RASSRVUI_VPN;
|
|
break;
|
|
|
|
case RDT_Irda:
|
|
case RDT_Parallel:
|
|
dwType = RASSRVUI_DCC;
|
|
break;
|
|
|
|
case RDT_Other:
|
|
default:
|
|
dwType = RASSRVUI_MODEM;
|
|
}
|
|
|
|
if (rdt & RDT_Tunnel)
|
|
{
|
|
dwType = RASSRVUI_VPN;
|
|
}
|
|
else if (rdt & (RDT_Direct | RDT_Null_Modem))
|
|
{
|
|
dwType = RASSRVUI_DCC;
|
|
}
|
|
return dwType;
|
|
}
|