able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/mprsnap/rtrutil.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3732 lines
107 KiB
C++
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
rtrutil.cpp
FILE HISTORY:
*/
#include "stdafx.h"
#include "rtrutilp.h"
#include "cnctdlg.h"
#include "cncting.h"
#include "rtrstr.h"
#include "ndisutil.h"
#include "netcfgx.h"
#include "register.h"
#include "raseapif.h"
#include "strings.h"
#include "reg.h" // IsNT4Machine
#include "ports.h"
#include "helper.h" // CStrParser
// Include headers needed for IP-specific infobase stuff
#include <rtinfo.h>
#include <fltdefs.h>
#include <ipinfoid.h>
#include <iprtrmib.h>
#include "iprtinfo.h"
// Headers needed for IPX-specific infobase stuff
#include "ipxrtdef.h"
#include <routprot.h> // protocol ids
#include <Wbemidl.h>
#define _PNP_POWER_
#include "ustringp.h"
#include "ntddip.h" // IP_PNP_RECONFIG_REQUEST
#include "ndispnp.h"
#include "globals.h" // structure defaults
#include "raserror.h"
#include "lsa.h" // RtlEncode/RtlDecode
#include "dsgetdc.h" // for DsGetDcName
#include "cmptrmgr.h" // for the computer management nodetype guid
extern "C"
{
#include "mprapip.h" // for MprAdminDomain functions
};
#include "rtutils.h" // Tracing functions
#include "rtrcomn.h" // CoCreateRouterConfig
#include "rrasutil.h"
//
// Timeouts used to control the behavior of ServiceStartPrompt/ServiceStop
//
#define TIMEOUT_START 5000
#define TIMEOUT_MAX 60000
#define TIMEOUT_POLL 5
#define MAX_WAIT_RESTART 60
extern "C" DWORD APIENTRY
MprConfigCreateIpInterfaceInfo(DWORD dwIfType, PBYTE ExistingHeader,
PBYTE* NewHeader );
//----------------------------------------------------------------------------
// Function: ConnectRouter
//
// Connects to the router on the specified machine
//----------------------------------------------------------------------------
TFSCORE_API(DWORD)
ConnectRouter(
IN LPCTSTR pszMachine,
OUT MPR_SERVER_HANDLE * phrouter
)
{
USES_CONVERSION;
//
// Connect to the router
//
Assert(*phrouter == NULL);
return ::MprAdminServerConnect(
T2W((LPTSTR) pszMachine),
phrouter
);
}
TFSCORE_API(DWORD)
GetRouterUpTime(IN LPCTSTR pszMachine,
OUT DWORD * pdwUpTime
)
{
DWORD dwError = NO_ERROR;
MPR_SERVER_HANDLE hMprServer = NULL;
Assert(pdwUpTime);
dwError = ConnectRouter(pszMachine, &hMprServer);
if (NO_ERROR == dwError && hMprServer)
{
MPR_SERVER_0* pServer0 = NULL;
dwError = MprAdminServerGetInfo(hMprServer, 0, (LPBYTE *) &pServer0);
if (NO_ERROR == dwError && pServer0)
{
*pdwUpTime = pServer0->dwUpTime;
MprAdminBufferFree(pServer0);
}
MprAdminServerDisconnect(hMprServer);
}
return dwError;
}
//----------------------------------------------------------------------------
// Function: GetRouterPhonebookPath
//
// Constructs the path to the router-phonebook file on the given machine.
//----------------------------------------------------------------------------
HRESULT
GetRouterPhonebookPath(
IN LPCTSTR pszMachine,
IN CString * pstPath
)
{
HRESULT hr = hrOK;
if (!IsLocalMachine(pszMachine))
{
// Assuming '\\\\' is appended before the call
Assert(StrnCmp(_T("\\\\"), pszMachine, 2) == 0);
//
// Supply the path via the 'ADMIN' share
//
*pstPath = pszMachine;
*pstPath += TEXT('\\');
*pstPath += c_szAdminShare;
*pstPath += TEXT('\\');
*pstPath += c_szSystem32;
*pstPath += TEXT('\\');
}
else
{
UINT i, j;
TCHAR* pszDir;
//
// Supply the path on the local machine
//
if (!(i = GetSystemDirectory(NULL, 0)))
return HResultFromWin32(GetLastError());
pszDir = new TCHAR[++i];
if (!GetSystemDirectory(pszDir, i))
{
hr = HResultFromWin32(GetLastError());
delete [] pszDir;
return hr;
}
*pstPath = pszDir;
*pstPath += TEXT('\\');
delete [] pszDir;
}
*pstPath += c_szRAS;
*pstPath += TEXT('\\');
*pstPath += c_szRouterPbk;
return hr;
}
/*!--------------------------------------------------------------------------
DeleteRouterPhonebook
Deletes the router.pbk of a machine
Author: KennT
---------------------------------------------------------------------------*/
HRESULT DeleteRouterPhonebook(LPCTSTR pszMachine)
{
HRESULT hr = hrOK;
CString stMachine, stPhonebookPath;
// Setup the server. If this is not the local machine, it will
// need to have \\ as a prefix.
// ----------------------------------------------------------------
stMachine = pszMachine;
if (!IsLocalMachine((LPCTSTR) stMachine))
{
// add on the two slashes to the beginning of the machine name
// ------------------------------------------------------------
if (stMachine.Left(2) != _T("\\\\"))
{
stMachine = _T("\\\\");
stMachine += pszMachine;
}
}
if (FHrOK(GetRouterPhonebookPath(stMachine, &stPhonebookPath)))
hr = HResultFromWin32( ::DeleteFile(stPhonebookPath) );
return hr;
}
/*!--------------------------------------------------------------------------
GetLocalMachineName
-
Author: KennT
---------------------------------------------------------------------------*/
CString GetLocalMachineName()
{
CString stMachine;
TCHAR szMachine[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
Verify(GetComputerName(szMachine, &dwSize));
stMachine = szMachine;
return stMachine;
}
TFSCORE_API(DWORD) ConnectInterfaceEx(
IN MPR_SERVER_HANDLE hRouter,
IN HANDLE hInterface,
IN BOOL bConnect,
IN HWND hwndParent,
IN LPCTSTR pszInterface)
{
DWORD dwErr;
Assert(hRouter);
Assert(hInterface);
//
// Initiate the interface connection/disconnection
//
if (!bConnect)
{
dwErr = ::MprAdminInterfaceDisconnect(hRouter, hInterface);
}
else
{
dwErr = ::MprAdminInterfaceConnect(hRouter, hInterface, NULL, FALSE);
if (dwErr == PENDING) { dwErr = NO_ERROR; }
//
// Display a dialog so user knows connection is in progress
//
CInterfaceConnectDialog dlg(hRouter, hInterface, pszInterface,
CWnd::FromHandle(hwndParent));
dlg.DoModal();
}
return dwErr;
}
/*!--------------------------------------------------------------------------
ConnectInterface
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(DWORD) ConnectInterface(
IN LPCTSTR pszMachine,
IN LPCTSTR pszInterface,
IN BOOL bConnect,
IN HWND hwndParent)
{
DWORD dwErr;
SPMprServerHandle sphRouter;
MPR_SERVER_HANDLE hRouter = NULL;
HANDLE hInterface;
WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
//
// Connect to the specified machine, if necessary
//
dwErr = ConnectRouter(pszMachine, &hRouter);
if (dwErr != NO_ERROR)
return dwErr;
sphRouter.Attach(hRouter); // so that it gets released
//
// Retrieve the interface handle, if necessary
//
StrCpyWFromT(wszInterface, pszInterface);
dwErr = ::MprAdminInterfaceGetHandle(
hRouter,
wszInterface,
&hInterface,
FALSE
);
if (dwErr != NO_ERROR)
return dwErr;
return ConnectInterfaceEx(hRouter, hInterface, bConnect, hwndParent,
pszInterface);
}
/*---------------------------------------------------------------------------
CInterfaceConnectDialog
---------------------------------------------------------------------------*/
CInterfaceConnectDialog::CInterfaceConnectDialog(
MPR_SERVER_HANDLE hServer,
HANDLE hInterface,
LPCTSTR pszInterface,
CWnd* pParent
) : CDialog(IDD_CONNECTING, pParent),
m_hServer(hServer),
m_hInterface(hInterface),
m_sInterface(pszInterface),
m_dwTimeElapsed(0),
m_dwConnectionState(ROUTER_IF_STATE_CONNECTING),
m_nIDEvent(1) { }
void
CInterfaceConnectDialog::DoDataExchange(CDataExchange* pDX) {
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CInterfaceConnectDialog)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CInterfaceConnectDialog, CDialog)
//{{AFX_MSG_MAP(CInterfaceConnectDialog)
ON_WM_TIMER()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CInterfaceConnectDialog::OnInitDialog()
{
SetDlgItemText(IDC_EDIT_INTERFACENAME, m_sInterface);
OnTimer(m_nIDEvent);
m_nIDEvent = SetTimer(m_nIDEvent, 1000, NULL);
GetDlgItem(IDCANCEL)->SetFocus();
return FALSE;
}
VOID CInterfaceConnectDialog::OnCancel()
{
::MprAdminInterfaceDisconnect(m_hServer, m_hInterface);
CDialog::OnCancel();
}
VOID
CInterfaceConnectDialog::OnTimer(
UINT nIDEvent
) {
DWORD dwErr;
CString sTime, sPrompt;
SPMprAdminBuffer spMprBuffer;
if (nIDEvent != m_nIDEvent)
{
CWnd::OnTimer(nIDEvent);
return;
}
++m_dwTimeElapsed;
if (!(m_dwTimeElapsed % TIMEOUT_POLL))
{
MPR_INTERFACE_0* pInfo;
dwErr = ::MprAdminInterfaceGetInfo(
m_hServer,
m_hInterface,
0,
(LPBYTE*)&spMprBuffer
);
pInfo = (MPR_INTERFACE_0 *) (LPBYTE) spMprBuffer;
if (dwErr == NO_ERROR)
{
m_dwConnectionState = pInfo->dwConnectionState;
if (m_dwConnectionState == ROUTER_IF_STATE_CONNECTED)
{
KillTimer(m_nIDEvent);
EndDialog(IDOK);
}
else if (m_dwConnectionState != ROUTER_IF_STATE_CONNECTING)
{
KillTimer(m_nIDEvent);
BringWindowToTop();
if (pInfo->dwLastError == NO_ERROR)
{
AfxMessageBox(IDS_ERR_IF_DISCONNECTED);
}
else
{
//Workaround for bugid: 96347. Change this once
//schannel has an alert for SEC_E_MULTIPLE_ACCOUNTS
if ( pInfo->dwLastError == SEC_E_CERT_UNKNOWN )
{
pInfo->dwLastError = SEC_E_MULTIPLE_ACCOUNTS;
}
FormatSystemError(HResultFromWin32(pInfo->dwLastError),
sPrompt.GetBuffer(1024),
1024,
IDS_ERR_IF_CONNECTFAILED,
FSEFLAG_ANYMESSAGE
);
sPrompt.ReleaseBuffer();
AfxMessageBox(sPrompt);
}
EndDialog(IDCANCEL);
}
}
}
sPrompt = ConnectionStateToCString(m_dwConnectionState);
SetDlgItemText(IDC_TEXT_IFSTATUS, sPrompt);
FormatNumber(m_dwTimeElapsed, sTime.GetBuffer(1024), 1024, FALSE);
sTime.ReleaseBuffer();
AfxFormatString1(sPrompt, IDS_SECONDSFMT, sTime);
SetDlgItemText(IDC_TEXT_ELAPSED, sPrompt);
}
/*!--------------------------------------------------------------------------
PromptForCredentials
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(DWORD) PromptForCredentials(LPCTSTR pszMachine,
LPCTSTR pszInterface,
BOOL fNT4,
BOOL fNewInterface,
HWND hwndParent)
{
HRESULT hr;
DWORD dwErr;
ULONG_PTR uConnection = 0;
SPMprServerHandle sphRouter;
MPR_SERVER_HANDLE hRouter = NULL;
HANDLE hInterface;
PMPR_INTERFACE_2 pmprInterface = NULL;
PMPR_CREDENTIALSEX_0 pmprCredentials = NULL;
BYTE* pUserDataOut = NULL;
WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
CIfCredentials dlg(pszMachine, pszInterface,
fNewInterface, CWnd::FromHandle(hwndParent));
if (fNT4)
{
dlg.DoModal();
return NO_ERROR;
}
//
// Connect to the specified machine
//
dwErr = ConnectRouter(pszMachine, &hRouter);
if (dwErr != NO_ERROR)
goto L_ERR;
//
// so that it gets released
//
sphRouter.Attach(hRouter);
//
// Retrieve the interface handle
//
StrCpyWFromT(wszInterface, pszInterface);
dwErr = ::MprAdminInterfaceGetHandle(
hRouter,
wszInterface,
&hInterface,
FALSE
);
if (dwErr != NO_ERROR)
goto L_ERR;
dwErr = ::MprAdminInterfaceGetInfo(hRouter, hInterface, 2,
(LPBYTE*)&pmprInterface);
if (dwErr != NO_ERROR)
goto L_ERR;
if (pmprInterface->dwfOptions & RASEO_RequireEAP)
{
GUID guid;
RegKey regkeyEAP;
RegKey regkeyEAPType;
CString stConfigCLSID;
DWORD dwInvokeUsername;
DWORD dwId;
DWORD dwSizeOfUserDataOut;
CComPtr<IEAPProviderConfig> spEAPConfig;
dwId = pmprInterface->dwCustomAuthKey;
TCHAR szStr[40];
_ltot((LONG)dwId, szStr, 10);
CString str(szStr);
dwErr = regkeyEAP.Open(HKEY_LOCAL_MACHINE,
c_szEAPKey, KEY_ALL_ACCESS, pszMachine);
if (ERROR_SUCCESS != dwErr)
goto L_ERR;
dwErr = regkeyEAPType.Open(regkeyEAP, str, KEY_READ);
if (ERROR_SUCCESS != dwErr)
goto L_ERR;
dwErr = regkeyEAPType.QueryValue(c_szInvokeUsernameDialog,
dwInvokeUsername);
if ((ERROR_SUCCESS == dwErr) && !dwInvokeUsername)
{
dwErr = ::MprAdminInterfaceGetCredentialsEx(hRouter, hInterface, 0,
(LPBYTE*)&pmprCredentials);
if (dwErr != NO_ERROR)
goto L_ERR;
dwErr = regkeyEAPType.QueryValue(c_szConfigCLSID, stConfigCLSID);
if (ERROR_SUCCESS != dwErr)
goto L_ERR;
CHECK_HR(hr = CLSIDFromString((LPTSTR)(LPCTSTR)stConfigCLSID,
&guid));
// Create the EAP provider object
CHECK_HR( hr = CoCreateInstance(
guid,
NULL,
CLSCTX_INPROC_SERVER | CLSCTX_ENABLE_CODE_DOWNLOAD,
IID_IEAPProviderConfig,
(LPVOID *) &spEAPConfig) );
// Configure this EAP provider
hr = spEAPConfig->Initialize(pszMachine, dwId, &uConnection);
if ( !FAILED(hr) )
{
hr = spEAPConfig->RouterInvokeCredentialsUI(dwId, uConnection,
hwndParent, RAS_EAP_FLAG_ROUTER,
pmprInterface->lpbCustomAuthData,
pmprInterface->dwCustomAuthDataSize,
pmprCredentials->lpbCredentialsInfo,
pmprCredentials->dwSize,
&pUserDataOut, &dwSizeOfUserDataOut);
spEAPConfig->Uninitialize(dwId, uConnection); // Ignore errors
}
if ( !FAILED(hr) )
{
pmprCredentials->lpbCredentialsInfo = pUserDataOut;
pmprCredentials->dwSize = dwSizeOfUserDataOut;
dwErr = ::MprAdminInterfaceSetCredentialsEx(hRouter, hInterface,
0, (LPBYTE)pmprCredentials);
if (dwErr != NO_ERROR)
goto L_ERR;
}
goto L_ERR;
}
}
dlg.DoModal();
L_ERR:
if (NULL != pmprInterface)
{
::MprAdminBufferFree(pmprInterface);
}
if (NULL != pmprCredentials)
{
::MprAdminBufferFree(pmprCredentials);
}
CoTaskMemFree(pUserDataOut);
return dwErr;
}
/*---------------------------------------------------------------------------
CIfCredentials
---------------------------------------------------------------------------*/
BEGIN_MESSAGE_MAP(CIfCredentials, CBaseDialog)
END_MESSAGE_MAP()
DWORD CIfCredentials::m_dwHelpMap[] =
{
IDC_EDIT_IC_USERNAME, 0,
IDC_EDIT_IC_DOMAIN, 0,
IDC_EDIT_IC_PASSWORD, 0,
IDC_EDIT_IC_PASSWORD2, 0,
0,0
};
BOOL
CIfCredentials::OnInitDialog(
) {
CBaseDialog::OnInitDialog();
((CEdit*)GetDlgItem(IDC_EDIT_IC_USERNAME))->LimitText(UNLEN);
((CEdit*)GetDlgItem(IDC_EDIT_IC_DOMAIN))->LimitText(DNLEN);
((CEdit*)GetDlgItem(IDC_EDIT_IC_PASSWORD))->LimitText(PWLEN);
((CEdit*)GetDlgItem(IDC_EDIT_IC_PASSWORD2))->LimitText(PWLEN);
//
// if you are editing a new interface, then you are done.
//
if ( m_bNewIf )
return FALSE;
//
// existing interface.
//
WCHAR wszPassword[PWLEN+1];
WCHAR wszPassword2[PWLEN+1];
do
{
DWORD dwErr = (DWORD) -1;
CString sErr;
WCHAR wszUsername[UNLEN+1];
WCHAR wszDomain[DNLEN+1];
WCHAR *pswzMachine = NULL;
WCHAR *pswzInterface = NULL;
//
// Retrieve its credentials
//
pswzMachine = (WCHAR *) alloca((m_sMachine.GetLength()+3) * sizeof(WCHAR));
StrCpyWFromT(pswzMachine, m_sMachine);
pswzInterface = (WCHAR *) alloca((m_sInterface.GetLength()+1) * sizeof(WCHAR));
StrCpyWFromT(pswzInterface, m_sInterface);
ZeroMemory( wszUsername, sizeof( wszUsername ) );
ZeroMemory( wszDomain, sizeof( wszDomain ) );
dwErr = MprAdminInterfaceGetCredentials(
pswzMachine,
pswzInterface,
wszUsername,
#if 1
NULL,
#else
wszPassword,
#endif
wszDomain
);
//
// if credentials were not retrieved successfully do not pop
// up message. It might mean that credentials have never been
// set before.
// Fix for bug # 79607.
//
if ( dwErr != NO_ERROR )
{
// FormatSystemError(dwErr, sErr, IDS_SET_CREDENTIALS_FAILED);
// AfxMessageBox(sErr);
break;
}
//
// fill the edit boxes with the values retrieved.
//
SetDlgItemTextW( IDC_EDIT_IC_USERNAME, wszUsername );
SetDlgItemTextW( IDC_EDIT_IC_DOMAIN, wszDomain );
} while ( FALSE );
ZeroMemory(wszPassword, sizeof(wszPassword));
ZeroMemory(wszPassword2, sizeof(wszPassword2));
// SetDlgItemText(IDC_EDIT_IC_USERNAME, m_sInterface);
return FALSE;
}
VOID
CIfCredentials::OnOK(
) {
DWORD dwErr;
CString sErr;
WCHAR wszMachine[MAX_COMPUTERNAME_LENGTH+3];
WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
WCHAR wszUsername[UNLEN+1];
WCHAR wszDomain[DNLEN+1];
WCHAR wszPassword[PWLEN+1];
WCHAR wszPassword2[PWLEN+1];
WCHAR* pwszPassword = NULL;
do {
//
// Retrieve the edit-controls' contents
//
wszUsername[0] = L'\0';
wszDomain[0] = L'\0';
wszPassword[0] = L'\0';
wszPassword2[0] = L'\0';
GetDlgItemTextW(IDC_EDIT_IC_USERNAME, wszUsername, UNLEN + 1);
GetDlgItemTextW(IDC_EDIT_IC_DOMAIN, wszDomain, DNLEN + 1);
GetDlgItemTextW(IDC_EDIT_IC_PASSWORD, wszPassword, PWLEN + 1);
GetDlgItemTextW(IDC_EDIT_IC_PASSWORD2, wszPassword2, PWLEN + 1);
//
// Make sure the password matches its confirmation
//
if (lstrcmpW(wszPassword, wszPassword2)) {
AfxMessageBox(IDS_ERR_PASSWORD_MISMATCH);
SetDlgItemText(IDC_EDIT_IC_PASSWORD, TEXT(""));
SetDlgItemText(IDC_EDIT_IC_PASSWORD2, TEXT(""));
GetDlgItem(IDC_EDIT_IC_PASSWORD)->SetFocus();
break;
}
//
// If no Password is present, see if the user wants to remove
// the password or just leave it unreplaced
//
if (lstrlen(wszPassword)) {
pwszPassword = wszPassword;
}
else {
INT id;
id = AfxMessageBox(IDS_PROMPT_NOPASSWORD, MB_YESNOCANCEL|MB_DEFBUTTON2);
if (id == IDYES) { pwszPassword = wszPassword; }
else
if (id == IDCANCEL) { break; }
}
//
// Save the credentials;
//
StrCpyWFromT(wszMachine, m_sMachine);
StrCpyWFromT(wszInterface, m_sInterface);
dwErr = MprAdminInterfaceSetCredentials(
wszMachine,
wszInterface,
wszUsername,
wszDomain,
pwszPassword
);
if (dwErr) {
FormatSystemError(dwErr, sErr.GetBuffer(1024), 1024, IDS_ERR_SET_CREDENTIALS_FAILED, 0xFFFFFFFF);
sErr.ReleaseBuffer();
AfxMessageBox(sErr);
break;
}
CBaseDialog::OnOK();
} while(FALSE);
//
// Erase the passwords from the stack.
//
ZeroMemory(wszPassword, sizeof(wszPassword));
ZeroMemory(wszPassword2, sizeof(wszPassword2));
return;
}
TFSCORE_API(DWORD) UpdateDDM(IInterfaceInfo *pIfInfo)
{
BOOL bStatus = FALSE;
DWORD dwErr = (DWORD) -1;
CString sErr;
MPR_SERVER_HANDLE hServer = NULL;
HANDLE hInterface = NULL;
WCHAR wszMachine[ MAX_COMPUTERNAME_LENGTH + 3 ];
WCHAR wszInterface[ MAX_INTERFACE_NAME_LEN + 1 ];
do
{
// Verify that the router service is running.
StrCpyWFromT( wszMachine, pIfInfo->GetMachineName() );
StrCpyWFromT( wszInterface, pIfInfo->GetId() );
bStatus = ::MprAdminIsServiceRunning( wszMachine );
if ( !bStatus )
{
dwErr = NO_ERROR;
break;
}
dwErr = ConnectRouter( pIfInfo->GetMachineName(), &hServer );
if ( dwErr != NO_ERROR )
break;
dwErr = ::MprAdminInterfaceGetHandle(
hServer,
wszInterface,
&hInterface,
FALSE);
if ( dwErr != NO_ERROR )
break;
// update phone book info. in DDM
dwErr = ::MprAdminInterfaceUpdatePhonebookInfo(
hServer,
hInterface
);
if (dwErr != NO_ERROR )
break;
} while ( FALSE );
if (hServer) { ::MprAdminServerDisconnect(hServer); }
if ( dwErr != NO_ERROR && dwErr != ERROR_NO_SUCH_INTERFACE )
{
FormatSystemError( dwErr, sErr.GetBuffer(1024), 1024, IDS_ERR_IF_CONNECTFAILED, 0xffffffff);
sErr.ReleaseBuffer();
AfxMessageBox( sErr );
}
return dwErr;
}
/*!--------------------------------------------------------------------------
UpdateRoutes
Performs an autostatic update on the given machine's interface,
for a specific transport.
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(DWORD) UpdateRoutesEx(IN MPR_SERVER_HANDLE hRouter,
IN HANDLE hInterface,
IN DWORD dwTransportId,
IN HWND hwndParent,
IN LPCTSTR pszInterface)
{
DWORD dwErr, dwState;
MPR_INTERFACE_0* pmprif0=NULL;
do {
// See if the interface is connected
dwErr = ::MprAdminInterfaceGetInfo(hRouter,
hInterface,
0,
(LPBYTE*)&pmprif0);
if (dwErr != NO_ERROR || pmprif0 == NULL) { break; }
dwState = pmprif0->dwConnectionState;
::MprAdminBufferFree(pmprif0);
// Establish the connection if necessary
if (dwState != (DWORD)ROUTER_IF_STATE_CONNECTED)
{
// Connect the interface
dwErr = ::ConnectInterfaceEx(hRouter,
hInterface,
TRUE,
hwndParent,
pszInterface);
if (dwErr != NO_ERROR) { break; }
}
//
// Now perform the route-update
//
dwErr = ::MprAdminInterfaceUpdateRoutes(
hRouter,
hInterface,
dwTransportId,
NULL
);
if (dwErr != NO_ERROR) { break; }
} while(FALSE);
return dwErr;
}
TFSCORE_API(DWORD) UpdateRoutes(IN LPCTSTR pszMachine,
IN LPCTSTR pszInterface,
IN DWORD dwTransportId,
IN HWND hwndParent)
{
DWORD dwErr, dwState;
HANDLE hInterface = INVALID_HANDLE_VALUE;
MPR_INTERFACE_0* pmprif0;
SPMprServerHandle sphRouter;
MPR_SERVER_HANDLE hMachine = NULL;;
//
// open a handle
//
dwErr = ConnectRouter(pszMachine, &hMachine);
if (dwErr != NO_ERROR)
return dwErr;
sphRouter.Attach(hMachine); // so that it gets released
do {
//
// open a handle to the interface
//
WCHAR wszInterface[MAX_INTERFACE_NAME_LEN + 1];
StrCpyWFromT(wszInterface, pszInterface);
dwErr = MprAdminInterfaceGetHandle(
hMachine,
wszInterface,
&hInterface,
FALSE
);
if (dwErr != NO_ERROR) { break; }
dwErr = ::UpdateRoutesEx(hMachine,
hInterface,
dwTransportId,
hwndParent,
pszInterface);
} while (FALSE);
return dwErr;
}
/*!--------------------------------------------------------------------------
ConnectAsAdmin
Connect to the remote machine as administrator with user-supplied
credentials.
Returns
S_OK - if a connection was established
S_FALSE - if user cancelled out
other - error condition
Author: KennT
---------------------------------------------------------------------------*/
HRESULT ConnectAsAdmin( IN LPCTSTR szRouterName, IN IRouterInfo *pRouter)
{
//
// allow user to specify credentials
//
DWORD dwRes = (DWORD) -1;
HRESULT hr = hrOK;
CConnectAsDlg caDlg;
CString stIPCShare;
CString stRouterName;
CString stPassword;
stRouterName = szRouterName;
//
// set message text in connect as dialog.
//
caDlg.m_sRouterName = szRouterName;
//
// loop till connect succeeds or user cancels
//
while ( TRUE )
{
// We need to ensure that this dialog is brought to
// the top (if it gets lost behind the main window, we
// are in trouble).
dwRes = caDlg.DoModal();
if ( dwRes == IDCANCEL )
{
hr = S_FALSE;
break;
}
//
// Create remote resource name
//
stIPCShare.Empty();
if ( stRouterName.Left(2) != TEXT( "\\\\" ) )
{
stIPCShare = TEXT( "\\\\" );
}
stIPCShare += stRouterName;
stIPCShare += TEXT( "\\" );
stIPCShare += c_szIPCShare;
NETRESOURCE nr;
nr.dwType = RESOURCETYPE_ANY;
nr.lpLocalName = NULL;
nr.lpRemoteName = (LPTSTR) (LPCTSTR) stIPCShare;
nr.lpProvider = NULL;
//
// connect to \\router\ipc$ to try and establish credentials.
// May not be the best way to establish credentials but is
// the most expendient for now.
//
// Need to unencode the password in the ConnectAsDlg
stPassword = caDlg.m_sPassword;
RtlDecodeW(caDlg.m_ucSeed, stPassword.GetBuffer(0));
stPassword.ReleaseBuffer();
//Remove Net Connections if there are any present
RemoveNetConnection( stIPCShare);
dwRes = WNetAddConnection2(
&nr,
(LPCTSTR) stPassword,
(LPCTSTR) caDlg.m_sUserName,
0
);
// We need to save off the user name and password
if (dwRes == NO_ERROR)
{
// Parse out the user name, use an arbitrary key for
// the encoding.
SPIRouterAdminAccess spAdmin;
// For every connection that succeeds we have to ensure
// that the connection gets removed. Do this by storing
// the connections globally. This will get freed up in
// the IComponentData destructor.
// --------------------------------------------------------
AddNetConnection((LPCTSTR) stIPCShare);
spAdmin.HrQuery(pRouter);
if (spAdmin)
{
UCHAR ucSeed = 0x83;
CString stName;
CString stUser;
CString stDomain;
LPCTSTR pszUser = NULL;
LPCTSTR pszDomain = NULL;
int iPos = 0;
// Break the user name into domain\user
// look for the first forward slash
stName = caDlg.m_sUserName;
if ((iPos = stName.FindOneOf(_T("\\"))) == -1)
{
// Couldn't find one, there is no domain info
pszUser = (LPCTSTR) stName;
pszDomain = NULL;
}
else
{
stUser = stName.Right(stName.GetLength() - iPos - 1);
stDomain = stName.Left(iPos);
pszUser = (LPCTSTR) stUser;
pszDomain = (LPCTSTR) stDomain;
}
// Use the key 0x83 for the password
RtlEncodeW(&ucSeed, stPassword.GetBuffer(0));
stPassword.ReleaseBuffer();
spAdmin->SetInfo(pszUser,
pszDomain,
(BYTE *) (LPCTSTR) stPassword,
stPassword.GetLength() * sizeof(WCHAR));
}
}
ZeroMemory(stPassword.GetBuffer(0),
stPassword.GetLength() * sizeof(TCHAR));
stPassword.ReleaseBuffer();
if ( dwRes != NO_ERROR )
{
PBYTE pbMsgBuf = NULL;
::FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dwRes,
MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language
(LPTSTR) &pbMsgBuf,
0,
NULL
);
AfxMessageBox( (LPCTSTR) pbMsgBuf );
LocalFree( pbMsgBuf );
}
else
{
//
// connection succeeded
//
hr = hrOK;
break;
}
}
return hr;
}
DWORD ValidateMachine(const CString &sName, BOOL bDisplayErr)
{
// We don't use this info just
// make the call to see if the server is out there. Hopefully
// this will be faster than the RegConnectRegistry call.
// We get info level 102 because this will also tell
// us if we have the correct permissions for the machine.
SERVER_INFO_102 *psvInfo102;
DWORD dwr = NetServerGetInfo((LPTSTR)(LPCTSTR)sName,
102, (LPBYTE*)&psvInfo102);
if (dwr == ERROR_SUCCESS)
{
NetApiBufferFree(psvInfo102);
}
else if (bDisplayErr)
{
CString str;
str.Format(IDS_ERR_THEREHASBEEN, sName);
AfxMessageBox(str);
}
return dwr;
}
/*!--------------------------------------------------------------------------
InitiateServerConnection
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InitiateServerConnection(LPCTSTR pszMachine,
HKEY *phkey,
BOOL fNoConnectingUI,
IRouterInfo *pRouter)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CConnectingDlg cnctingdlg;
DWORD dwRes = IDOK;
HRESULT hr = hrOK;
COSERVERINFO csi;
COAUTHINFO cai;
COAUTHIDENTITY caid;
IUnknown * punk = NULL;
Assert(phkey);
cnctingdlg.m_sName = pszMachine;
// Display the connecting dialog if requested
if (fNoConnectingUI)
{
if (!cnctingdlg.Connect())
dwRes = 0;
}
else
{
dwRes = cnctingdlg.DoModal();
}
if ( !IsLocalMachine(pszMachine) )
{
ZeroMemory(&csi, sizeof(csi));
ZeroMemory(&cai, sizeof(cai));
ZeroMemory(&caid, sizeof(caid));
csi.pAuthInfo = &cai;
cai.pAuthIdentityData = &caid;
hr = CoCreateRouterConfig(pszMachine,
pRouter,
&csi,
IID_IRemoteNetworkConfig,
&punk) ;
if ( hrOK != hr )
{
cnctingdlg.m_dwr = ERROR_ACCESS_DENIED;
dwRes = 0;
}
else
{
if ( punk ) punk->Release();
}
}
// check and see if we were successful
if (dwRes == IDCANCEL)
{
*phkey = NULL;
hr = S_FALSE;
goto Error;
}
else if (dwRes != IDOK)
{
DisplayConnectErrorMessage(cnctingdlg.m_dwr);
hr = HResultFromWin32(cnctingdlg.m_dwr);
if ((cnctingdlg.m_dwr != ERROR_ACCESS_DENIED) &&
(cnctingdlg.m_dwr != ERROR_LOGON_FAILURE))
{
hr = HResultFromWin32(cnctingdlg.m_dwr);
goto Error;
}
// If there was an access denied error, we ask the
// user to see if they can supply different credentials
hr = ConnectAsAdmin(pszMachine, pRouter);
if (!FHrOK(hr))
{
*phkey = NULL;
hr = HResultFromWin32(ERROR_CANCELLED);
goto Error;
}
// try it again with the new credentials
dwRes = cnctingdlg.DoModal();
if (dwRes != IDOK)
{
DisplayConnectErrorMessage(cnctingdlg.m_dwr);
hr = HResultFromWin32(cnctingdlg.m_dwr);
goto Error;
}
}
// successful connection
if(phkey)
*phkey = cnctingdlg.m_hkMachine;
else
DisconnectRegistry(cnctingdlg.m_hkMachine);
Error:
return hr;
}
void DisplayConnectErrorMessage(DWORD dwr)
{
switch (dwr)
{
case ERROR_ACCESS_DENIED:
AfxMessageBox(IDS_ERR_ACCESSDENIED);
break;
case ERROR_BAD_NETPATH:
AfxMessageBox(IDS_ERR_NETPATHNOTFOUND);
break;
default:
DisplayIdErrorMessage2(NULL, IDS_ERR_ERRORCONNECT,
HResultFromWin32(dwr));
break;
}
}
/*!--------------------------------------------------------------------------
IsRouterServiceRunning
This will return hrOK if the service is running.
This will return hrFalse if the service is stopped (and no error).
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) IsRouterServiceRunning(IN LPCWSTR pszMachine,
OUT DWORD *pdwErrorCode)
{
HRESULT hr = hrOK;
DWORD dwServiceStatus = 0;
hr = GetRouterServiceStatus(pszMachine, &dwServiceStatus, pdwErrorCode);
if (FHrSucceeded(hr))
{
hr = (dwServiceStatus == SERVICE_STOPPED) ? hrFalse : hrOK;
}
return hr;
}
/*!--------------------------------------------------------------------------
GetRouterServiceStatus
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) GetRouterServiceStatus(LPCWSTR pszMachine,
DWORD *pdwStatus,
DWORD *pdwErrorCode)
{
HRESULT hr = hrOK;
DWORD dwServiceStatus = 0;
Assert(pdwStatus);
// First check the Router service (for Steelhead)
// ----------------------------------------------------------------
hr = HResultFromWin32(TFSGetServiceStatus(pszMachine,
c_szRouter,
&dwServiceStatus,
pdwErrorCode));
// If that failed, then we look at the RemoteAccess
// ----------------------------------------------------------------
if (!FHrSucceeded(hr) || (dwServiceStatus == SERVICE_STOPPED))
{
hr = HResultFromWin32(TFSGetServiceStatus(pszMachine,
c_szRemoteAccess,
&dwServiceStatus,
pdwErrorCode) );
}
if (FHrSucceeded(hr))
{
*pdwStatus = dwServiceStatus;
}
return hr;
}
TFSCORE_API(HRESULT) GetRouterServiceStartType(LPCWSTR pszMachine, DWORD *pdwStartType)
{
HRESULT hr = hrOK;
DWORD dwStartType = 0;
Assert(pdwStartType);
// First check the Router service (for Steelhead)
// ----------------------------------------------------------------
hr = HResultFromWin32(TFSGetServiceStartType(pszMachine,
c_szRouter, &dwStartType) );
// If that failed, then we look at the RemoteAccess service
// ----------------------------------------------------------------
if (!FHrSucceeded(hr))
{
hr = HResultFromWin32(TFSGetServiceStartType(pszMachine,
c_szRemoteAccess,
&dwStartType) );
}
//Error:
if (FHrSucceeded(hr))
{
*pdwStartType = dwStartType;
}
return hr;
}
TFSCORE_API(HRESULT) SetRouterServiceStartType(LPCWSTR pszMachine, DWORD dwStartType)
{
HRESULT hr = hrOK;
// Set the start type for both the Router and RemoteAccess
// ----------------------------------------------------------------
hr = HResultFromWin32(TFSSetServiceStartType(pszMachine,
c_szRouter, dwStartType) );
hr = HResultFromWin32(TFSSetServiceStartType(pszMachine,
c_szRemoteAccess,
dwStartType) );
return hr;
}
TFSCORE_API(HRESULT) ErasePSK(LPCWSTR pszMachine )
{
DWORD dwErr = ERROR_SUCCESS;
HANDLE hMprServer = NULL;
WCHAR szEmptyPSK[5] = {0};
HRESULT hr = hrOK;
MPR_CREDENTIALSEX_0 MprCredentials;
dwErr = ::MprAdminServerConnect((LPWSTR)pszMachine , &hMprServer);
if ( ERROR_SUCCESS != dwErr )
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Error;
}
ZeroMemory(&MprCredentials, sizeof(MprCredentials));
//Setup the MprCredentials structure
MprCredentials.dwSize = 0;
MprCredentials.lpbCredentialsInfo = (LPBYTE)szEmptyPSK;
dwErr = MprAdminServerSetCredentials( hMprServer, 0, (LPBYTE)&MprCredentials );
if ( ERROR_SUCCESS != dwErr )
{
//Special case! If 13011 is returned, ignore it.
//This is because, the ipsec filter is not yet loaded and
//we are making calls to remove it.
if ( ERROR_IPSEC_MM_AUTH_NOT_FOUND != dwErr )
{
hr = HRESULT_FROM_WIN32(dwErr);
goto Error;
}
}
Error:
if ( hMprServer )
::MprAdminServerDisconnect(hMprServer);
return hr;
}
/*!--------------------------------------------------------------------------
StartRouterService
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) StartRouterService(LPCWSTR pszMachine)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
CString stServiceDesc;
DWORD dwErr;
BOOL fNt4 = FALSE;
LPCTSTR pszServiceName = NULL;
HKEY hkeyMachine = NULL;
DWORD dwErasePSK = 0;
COM_PROTECT_TRY
{
// Ignore the failure code, what else can we do?
// ------------------------------------------------------------
dwErr = ConnectRegistry(pszMachine, &hkeyMachine);
if (dwErr == ERROR_SUCCESS)
{
IsNT4Machine(hkeyMachine, &fNt4);
DisconnectRegistry(hkeyMachine);
}
// Windows Nt Bug : 277121
// If this is an NT4 machine, try to start the Router service
// rather than the RemoteAccess service.
// ------------------------------------------------------------
// pszServiceName = (fNt4 ? c_szRouter : c_szRemoteAccess);
pszServiceName = c_szRemoteAccess;
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
dwErr = TFSStartService(pszMachine,
pszServiceName,
stServiceDesc);
hr = HResultFromWin32(dwErr);
if (FHrOK(hr))
{
BOOL fIsRunning = FALSE;
// Windows NT Bug : 254167
// Need to check to see if the service is running
// (an error could have occurred in the StartService).
// --------------------------------------------------------
dwErr = TFSIsServiceRunning(pszMachine,
pszServiceName,
&fIsRunning);
if ((dwErr == ERROR_SUCCESS) && fIsRunning)
{
// Now we need to wait for the router to actually start
// running.
CString stText;
CString stTitle;
stText.LoadString(IDS_WAIT_FOR_RRAS);
stTitle.LoadString(IDS_WAIT_FOR_RRAS_TITLE);
CWaitForRemoteAccessDlg dlg(pszMachine, stText, stTitle, NULL);
dlg.DoModal();
}
//Now that the router service is started, check to see if PSK
//needs to be cleaned up
if ( FHrSucceeded (ReadErasePSKReg(pszMachine, &dwErasePSK) ) )
{
if ( dwErasePSK )
{
//What if the thing fails here. Cannot do much
if ( FHrSucceeded(ErasePSK (pszMachine)) )
{
WriteErasePSKReg(pszMachine, 0 );
}
}
}
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
StopRouterService
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) StopRouterService(LPCWSTR pszMachine)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
CString stServiceDesc;
DWORD dwErr;
COM_PROTECT_TRY
{
// Load the description for the SAP Agent
stServiceDesc.LoadString(IDS_SAPAGENT_SERVICE_DESC);
// Stop the SAP Agent
// ------------------------------------------------------------
dwErr = TFSStopService(pszMachine,
c_szNWSAPAgent,
stServiceDesc);
// Load the description for the router
// ------------------------------------------------------------
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
// Stop the router service
// ------------------------------------------------------------
dwErr = TFSStopService(pszMachine,
c_szRouter,
stServiceDesc);
// Stop the RemoteAccess service
// ------------------------------------------------------------
dwErr = TFSStopService(pszMachine,
c_szRemoteAccess,
stServiceDesc);
// If we get the ERROR_SERVICE_NOT_ACTIVE, this is ok since
// we are trying to stop the service anyway.
// ------------------------------------------------------------
if (dwErr == ERROR_SERVICE_NOT_ACTIVE)
hr = hrOK;
else
hr = HResultFromWin32(dwErr);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
ForceGlobalRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) ForceGlobalRefresh(IRouterInfo *pRouter)
{
// Call through to the refresh object to start a refresh action
SPIRouterRefresh spRefresh;
HRESULT hr = hrOK;
if (pRouter == NULL)
CORg( E_INVALIDARG );
CORg( pRouter->GetRefreshObject(&spRefresh) );
if (spRefresh)
CORg( spRefresh->Refresh() );
Error:
return hr;
}
/*!--------------------------------------------------------------------------
FormatRasPortName
-
Author: KennT
---------------------------------------------------------------------------*/
void FormatRasPortName(BYTE *pRasPort0, LPTSTR pszBuffer, UINT cchMax)
{
RAS_PORT_0 * prp0 = (RAS_PORT_0 *) pRasPort0;
CString stName;
stName.Format(_T("%ls (%ls)"), prp0->wszDeviceName, prp0->wszPortName);
StrnCpy(pszBuffer, (LPCTSTR) stName, cchMax);
pszBuffer[cchMax-1] = 0;
}
static CString s_PortNonOperational;
static CString s_PortDisconnected;
static CString s_PortCallingBack;
static CString s_PortListening;
static CString s_PortAuthenticating;
static CString s_PortAuthenticated;
static CString s_PortInitializing;
static CString s_PortUnknown;
static const CStringMapEntry s_PortConditionMap[] =
{
{ RAS_PORT_NON_OPERATIONAL, &s_PortNonOperational, IDS_PORT_NON_OPERATIONAL },
{ RAS_PORT_DISCONNECTED, &s_PortDisconnected, IDS_PORT_DISCONNECTED },
{ RAS_PORT_CALLING_BACK, &s_PortCallingBack, IDS_PORT_CALLING_BACK },
{ RAS_PORT_LISTENING, &s_PortListening, IDS_PORT_LISTENING },
{ RAS_PORT_AUTHENTICATING, &s_PortAuthenticating, IDS_PORT_AUTHENTICATING },
{ RAS_PORT_AUTHENTICATED, &s_PortAuthenticated, IDS_PORT_AUTHENTICATED },
{ RAS_PORT_INITIALIZING, &s_PortInitializing, IDS_PORT_INITIALIZING },
{ -1, &s_PortUnknown, IDS_PORT_UNKNOWN },
};
/*!--------------------------------------------------------------------------
PortConditionToCString
-
Author: KennT
---------------------------------------------------------------------------*/
CString& PortConditionToCString(DWORD dwPortCondition)
{
return MapDWORDToCString(dwPortCondition, s_PortConditionMap);
}
static CString s_stPortsDeviceTypeNoUsage;
static CString s_stPortsDeviceTypeRouting;
static CString s_stPortsDeviceTypeRas;
static CString s_stPortsDeviceTypeRasRouting;
static CString s_stPortsDeviceTypeUnknown;
static const CStringMapEntry s_PortsDeviceTypeMap[] =
{
{ 0, &s_stPortsDeviceTypeNoUsage, IDS_PORTSDLG_COL_NOUSAGE },
{ 1, &s_stPortsDeviceTypeRouting, IDS_PORTSDLG_COL_ROUTING },
{ 2, &s_stPortsDeviceTypeRas, IDS_PORTSDLG_COL_RAS },
{ 3, &s_stPortsDeviceTypeRasRouting, IDS_PORTSDLG_COL_RASROUTING },
{ -1, &s_stPortsDeviceTypeUnknown, IDS_PORTSDLG_COL_UNKNOWN },
};
CString& PortsDeviceTypeToCString(DWORD dwRasRouter)
{
return MapDWORDToCString(dwRasRouter, s_PortsDeviceTypeMap);
}
/*!--------------------------------------------------------------------------
RegFindInterfaceKey
-
This function returns the HKEY of the router interface with this ID.
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RegFindInterfaceKey(LPCTSTR pszInterface,
HKEY hkeyMachine,
REGSAM regAccess,
HKEY *pHKey)
{
HRESULT hr = hrFalse;
HKEY hkey = 0;
RegKey regkey;
RegKey regkeyIf;
RegKeyIterator regkeyIter;
HRESULT hrIter;
CString stValue;
CString stKey;
DWORD dwErr;
COM_PROTECT_TRY
{
// Open up the remoteaccess key
CWRg( regkey.Open(hkeyMachine, c_szInterfacesKey) );
// Now look for the key that matches this one
CORg( regkeyIter.Init(&regkey) );
for (hrIter = regkeyIter.Next(&stKey); hrIter == hrOK; hrIter = regkeyIter.Next(&stKey))
{
regkeyIf.Close();
// Open the key
dwErr = regkeyIf.Open(regkey, stKey, regAccess);
if (dwErr != ERROR_SUCCESS)
continue;
CORg( regkeyIf.QueryValue(c_szInterfaceName, stValue) );
if (stValue.CompareNoCase(pszInterface) == 0)
{
// Ok, we found the key that we want
if (pHKey)
{
*pHKey = regkeyIf.Detach();
hr = hrOK;
}
}
}
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
// hour map ( one bit for an hour of a week )
static BYTE s_bitSetting[8] = { 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1};
//====================================================
// convert a List of Strings to Hour Map
// Strings in following format: 0 1:00-12:00 15:00-17:00
// hour map: a bit for an hour, 7 * 24 hours = 7 * 3 bytes
void StrListToHourMap(CStringList& stList, BYTE* map)
{
CStrParser Parser;
int sh, sm, eh, em = 0; // start hour, (min), end hour (min)
int day;
BYTE* pHourMap;
int i;
POSITION pos;
pos = stList.GetHeadPosition();
memset(map, 0, sizeof(BYTE) * 21);
while (pos)
{
Parser.SetStr( stList.GetNext(pos) );
Parser.SkipBlank();
day = Parser.DayOfWeek();
Parser.SkipBlank();
if(day == -1) continue;
pHourMap = map + sizeof(BYTE) * 3 * day;
while(-1 != (sh = Parser.GetUINT())) // sh:sm-eh:em
{
Parser.GotoAfter(_T(':'));
if(-1 == (sm = Parser.GetUINT())) // min
break;
Parser.GotoAfter(_T('-'));
if(-1 == (eh = Parser.GetUINT())) // hour
break;
if(-1 == (sm = Parser.GetUINT())) // min
break;
sm %= 60; sh %= 24; em %= 60; eh %= 25; // since we have end hour of 24:00
for(i = sh; i < eh; i++)
{
*(pHourMap + i / 8) |= s_bitSetting[i % 8];
}
}
}
}
//=====================================================
// convert value from map to strings
void HourMapToStrList(BYTE* map, CStringList& stList)
{
int sh, eh; // start hour, (min), end hour (min)
BYTE* pHourMap;
int i, j;
CString* pStr;
CString tmpStr;
// update the profile table
pHourMap = map;
stList.RemoveAll();
for( i = 0; i < 7; i++) // for each day
{
// if any value for this day
if(*pHourMap || *(pHourMap + 1) || *(pHourMap + 2))
{
// the string for this day
try{
pStr = NULL;
pStr = new CString;
// Print out the day, the day of the week is
// represented by an integer (0-6)
pStr->Format(_T("%d"), i);
sh = -1; eh = -1; // not start yet
for(j = 0; j < 24; j++) // for every hour
{
int k = j / 8;
int m = j % 8;
if(*(pHourMap + k) & s_bitSetting[m]) // this hour is on
{
if(sh == -1) sh = j; // set start hour is empty
eh = j; // extend end hour
}
else // this is not on
{
if(sh != -1) // some hours need to write out
{
tmpStr.Format(_T(" %02d:00-%02d:00"), sh, eh + 1);
*pStr += tmpStr;
sh = -1; eh = -1;
}
}
}
if(sh != -1)
{
tmpStr.Format(_T(" %02d:00-%02d:00"), sh, eh + 1);
*pStr += tmpStr;
sh = -1; eh = -1;
}
stList.AddTail(*pStr);
}
catch(CMemoryException&)
{
// AfxMessageBox(IDS_OUTOFMEMORY);
delete pStr;
stList.RemoveAll();
return;
}
}
pHourMap += 3;
}
}
/*!--------------------------------------------------------------------------
SetGlobalRegistrySettings
hkeyMachine - HKEY of the local machine key
fInstall - TRUE if we are installing
fChangeEnableRouter - TRUE if we can change the router key
(This is NOT the value of IpEnableRouter, but only if we are
allowed to change the value of this key).
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetGlobalRegistrySettings(HKEY hkeyMachine,
BOOL fInstall,
BOOL fChangeEnableRouter)
{
HRESULT hr = hrOK;
RegKey regkey;
DWORD dwInstall = fInstall;
DWORD dwNotInstall = !fInstall;
DWORD dwErr;
// Open the TcpIp parmeters key
if (regkey.Open(hkeyMachine, c_szRegKeyTcpipParameters) != ERROR_SUCCESS)
{
// No need to set the error return code, if an error occurs
// assume that the key doesn't exist.
goto Error;
}
// Set IPEnableRouter to (fInstall)
if (fChangeEnableRouter)
CWRg( regkey.SetValue(c_szRegValIpEnableRouter, dwInstall) );
// regkey.SetValue(c_szRegValIpEnableRouterBackup, dwNotInstall);
// Set EnableICMPRedirect to (!fInstall)
CWRg( regkey.SetValue(c_szRegValEnableICMPRedirect, dwNotInstall) );
// Set the defaults for the new adapters
CWRg( regkey.SetValue(c_szRegValDeadGWDetectDefault, dwNotInstall) );
CWRg( regkey.SetValue(c_szRegValDontAddDefaultGatewayDefault, dwInstall) );
Error:
return hr;
}
/*!--------------------------------------------------------------------------
SetPerInterfaceRegistrySettings
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetPerInterfaceRegistrySettings(HKEY hkeyMachine, BOOL fInstall)
{
HRESULT hr = hrOK;
DWORD dwInstall = fInstall;
DWORD dwNotInstall = !fInstall;
RegKey rkAdapters;
RegKey rkAdapter;
RegKeyIterator rkIter;
HRESULT hrIter;
CString stAdapter;
CStringList stIfList;
DWORD dwErr;
POSITION posIf;
RegKey rkIf;
CString stKey;
CString stIf;
// Get the key to the adapters section of TcpIp services
if (rkAdapters.Open(hkeyMachine, c_szRegKeyTcpipAdapters) != ERROR_SUCCESS)
{
// No need to set the error return code, if an error occurs
// assume that the key doesn't exist.
goto Error;
}
CORg( rkIter.Init(&rkAdapters) );
// Iterate through all of the adapters and set the key
for ( hrIter = rkIter.Next(&stAdapter); hrIter == hrOK; hrIter=rkIter.Next(&stAdapter) )
{
rkAdapter.Close();
// Open the adapter key
// ------------------------------------------------------------
dwErr = rkAdapter.Open(rkAdapters, stAdapter);
if (dwErr != ERROR_SUCCESS)
{
continue;
}
// Now that we have the adapter, we open up the IpConfig key
// to get the list of interfaces that match up to this adapter.
// ------------------------------------------------------------
CWRg( rkAdapter.QueryValue(c_szRegValIpConfig, stIfList) );
// Iterate through the interface list and set these values
// on each interface
// ------------------------------------------------------------
posIf = stIfList.GetHeadPosition();
while (posIf)
{
stIf = stIfList.GetNext(posIf);
// Create the right key
// --------------------------------------------------------
stKey = c_szSystemCCSServices;
stKey += _T('\\');
stKey += stIf;
rkIf.Close();
CWRg( rkIf.Open(hkeyMachine, stKey) );
// Set DeadGWDetect to (!fInstall) for each interface
// --------------------------------------------------------
dwErr = rkIf.SetValue(c_szRegValDeadGWDetect, dwNotInstall);
// Windows NT Bug: 168546
// Set DontAddDefaultGateway to (fInstall) only on Ndiswan adapters
// not ALL adapters.
// --------------------------------------------------------
if (stAdapter.Left(7).CompareNoCase(_T("NdisWan")) == 0)
{
dwErr = rkIf.SetValue(c_szRegValDontAddDefaultGateway, dwInstall);
}
}
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
InstallGlobalSettings
Sets the global settings (i.e. registry settings) on this machine
when the router is installed.
For a specific description of the actions involved, look at
the comments in the code.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InstallGlobalSettings(LPCTSTR pszMachineName, IRouterInfo *pRouter)
{
HRESULT hr = hrOK;
RouterVersionInfo routerVersion;
BOOL fSetIPEnableRouter = FALSE;
// We can change the IPEnableRouter only if this is the right build.
// ----------------------------------------------------------------
if (pRouter)
{
pRouter->GetRouterVersionInfo(&routerVersion);
}
else
{
// Need to get the version info manually
// ------------------------------------------------------------
HKEY hkeyMachine = NULL;
if (ERROR_SUCCESS == ConnectRegistry(pszMachineName, &hkeyMachine))
QueryRouterVersionInfo(hkeyMachine, &routerVersion);
if (hkeyMachine)
DisconnectRegistry(hkeyMachine);
}
if (routerVersion.dwOsBuildNo <= USE_IPENABLEROUTER_VERSION)
fSetIPEnableRouter = TRUE;
CORg( SetRouterInstallRegistrySettings(pszMachineName, TRUE, fSetIPEnableRouter) );
NotifyTcpipOfChanges(pszMachineName,
pRouter,
fSetIPEnableRouter /*fEnableRouter*/,
IP_IRDP_DISABLED /*uPerformRouterDiscovery*/);
Error:
return hr;
}
/*!--------------------------------------------------------------------------
UninstallGlobalSettings
Clears the global settings (i.e. registry settings) on this machine
when the router is installed.
Set fSnapinChanges to TRUE if you want to write out the various
snapin changes.
For a specific description of the actions involved, look at
the comments in the code.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT UninstallGlobalSettings(LPCTSTR pszMachineName,
IRouterInfo *pRouter,
BOOL fNt4,
BOOL fSnapinChanges)
{
HRESULT hr = hrOK;
DWORD dwStatus = SERVICE_RUNNING;
DWORD dwErr = ERROR_SUCCESS;
BOOL fChange;
// Windows NT Bug : 273047
// Check to see if the SharedAccess service is running.
// We need to check this only for NT4
// ----------------------------------------------------------------
if (!fNt4)
{
DWORD dwErrT;
// Get the status of the SharedAccess service. If we cannot
// get the status of the service, we assume that the service
// is stopped.
// ------------------------------------------------------------
dwErrT = TFSGetServiceStatus(pszMachineName, c_szSharedAccess,
&dwStatus, &dwErr);
// If we have a problem with the API, or if the API reported
// a service-specific error, we assume the service is stopped.
// ------------------------------------------------------------
if ((dwErrT != ERROR_SUCCESS) || (dwErr != ERROR_SUCCESS))
dwStatus = SERVICE_STOPPED;
}
// If the SharedAccess service is running, then we do NOT want to
// change the IpEnableRouter key.
// ----------------------------------------------------------------
fChange = (dwStatus == SERVICE_RUNNING);
// This will ALWAYS set the IPEnableRouter key to 0, which is fine
// with us. (We do not need to check the version).
// ----------------------------------------------------------------
CORg( SetRouterInstallRegistrySettings(pszMachineName, FALSE, !fChange) );
if (fSnapinChanges)
{
CORg( WriteRouterConfiguredReg(pszMachineName, FALSE) );
CORg( WriteRRASExtendsComputerManagementKey(pszMachineName, FALSE) );
}
NotifyTcpipOfChanges(pszMachineName,
pRouter,
FALSE /* fEnableRouter */,
IP_IRDP_DISABLED_USE_DHCP /* uPerformRouterDiscovery */);
Error:
return hr;
}
/*!--------------------------------------------------------------------------
WriteErasePSKReg
-
Author: Vivekk
---------------------------------------------------------------------------*/
HRESULT WriteErasePSKReg (LPCTSTR pszServerName, DWORD dwErasePSK )
{
HRESULT hr = hrOK;
RegKey regkey;
if (ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE,c_szRemoteAccessKey,KEY_ALL_ACCESS, pszServerName) )
CWRg(regkey.SetValue( c_szRouterPSK, dwErasePSK));
Error:
return hr;
}
/*!--------------------------------------------------------------------------
ReadErasePSKReg
-
Author: Vivekk
---------------------------------------------------------------------------*/
HRESULT ReadErasePSKReg(LPCTSTR pszServerName, DWORD *pdwErasePSK)
{
HRESULT hr = hrOK;
RegKey regkey;
Assert(pdwErasePSK);
CWRg( regkey.Open(HKEY_LOCAL_MACHINE,
c_szRemoteAccessKey,
KEY_ALL_ACCESS,
pszServerName) );
CWRg( regkey.QueryValue( c_szRouterPSK, *pdwErasePSK) );
Error:
// If we can't find the key, we assume that the router has not
// been configured.
// ----------------------------------------------------------------
if (hr == HResultFromWin32(ERROR_FILE_NOT_FOUND))
{
hr = hrOK;
*pdwErasePSK = FALSE;
}
return hr;
}
/*!--------------------------------------------------------------------------
WriteRouterConfiguredReg
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT WriteRouterConfiguredReg(LPCTSTR pszServerName, DWORD dwConfigured)
{
HRESULT hr = hrOK;
RegKey regkey;
if (ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE,c_szRemoteAccessKey,KEY_ALL_ACCESS, pszServerName) )
CWRg(regkey.SetValue( c_szRtrConfigured, dwConfigured));
Error:
return hr;
}
/*!--------------------------------------------------------------------------
ReadRouterConfiguredReg
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT ReadRouterConfiguredReg(LPCTSTR pszServerName, DWORD *pdwConfigured)
{
HRESULT hr = hrOK;
RegKey regkey;
Assert(pdwConfigured);
CWRg( regkey.Open(HKEY_LOCAL_MACHINE,
c_szRemoteAccessKey,
KEY_ALL_ACCESS,
pszServerName) );
CWRg( regkey.QueryValue( c_szRtrConfigured, *pdwConfigured) );
Error:
// If we can't find the key, we assume that the router has not
// been configured.
// ----------------------------------------------------------------
if (hr == HResultFromWin32(ERROR_FILE_NOT_FOUND))
{
hr = hrOK;
*pdwConfigured = FALSE;
}
return hr;
}
/*!--------------------------------------------------------------------------
WriteRRASExtendsComputerManagement
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT WriteRRASExtendsComputerManagementKey(LPCTSTR pszServer, DWORD dwConfigured)
{
HRESULT hr = hrOK;
RegKey rkMachine;
TCHAR szGuid[128];
// Stringize the RRAS GUID
::StringFromGUID2(CLSID_RouterSnapinExtension, szGuid, DimensionOf(szGuid));
CWRg( rkMachine.Open(HKEY_LOCAL_MACHINE, c_szRegKeyServerApplications,
KEY_ALL_ACCESS, pszServer) );
if (dwConfigured)
{
// Need to add the following key
// HKLM \ System \ CurrentControlSet \ Control \ Server Applications
// <GUID> : REG_SZ : some string
CWRg( rkMachine.SetValue(szGuid, _T("Remote Access and Routing")) );
}
else
{
// Need to remove the following key
// HKLM \ System \ CurrentControlSet \ Control \ Server Applications
// <GUID> : REG_SZ : some string
CWRg( rkMachine.DeleteValue( szGuid ) );
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
NotifyTcpipOfChanges
-
Author: KennT
---------------------------------------------------------------------------*/
void NotifyTcpipOfChanges(LPCTSTR pszMachineName,
IRouterInfo *pRouter,
BOOL fEnableRouter,
UCHAR uPerformRouterDiscovery)
{
HRESULT hr = hrOK;
RegKey rkInterfaces;
RegKey rkIf;
RegKeyIterator rkIter;
HRESULT hrIter;
CString stKey;
DWORD dwErr;
COSERVERINFO csi;
COAUTHINFO cai;
COAUTHIDENTITY caid;
ZeroMemory(&csi, sizeof(csi));
ZeroMemory(&cai, sizeof(cai));
ZeroMemory(&caid, sizeof(caid));
csi.pAuthInfo = &cai;
cai.pAuthIdentityData = &caid;
// For now, notify the user that they will have to
// reboot the machine locally.
if (!IsLocalMachine(pszMachineName))
{
SPIRemoteTCPIPChangeNotify spNotify;
// Create the remote config object
// ----------------------------------------------------------------
hr = CoCreateRouterConfig(pszMachineName,
pRouter,
&csi,
IID_IRemoteTCPIPChangeNotify,
(IUnknown**)&spNotify);
if (FAILED(hr)) goto Error;
// Upgrade the configuration (ensure that the registry keys
// are populated correctly).
// ------------------------------------------------------------
// Still do the notification for remote machines in case it is running
// an old build
Assert(spNotify);
hr = spNotify->NotifyChanges(fEnableRouter, uPerformRouterDiscovery);
spNotify.Release();
if (csi.pAuthInfo)
delete csi.pAuthInfo->pAuthIdentityData->Password;
}
else
{
// For the local case,
// Don't need to do any notification after bug 405636 and 345700 got fixed
}
Error:
if (!FHrSucceeded(hr))
{
if (hr == NETCFG_S_REBOOT)
AfxMessageBox(IDS_WRN_INSTALL_REBOOT_NOTIFICATION);
else
DisplayErrorMessage(NULL, hr);
}
}
/*!--------------------------------------------------------------------------
AddIpPerInterfaceBlocks
Setup this interface's infobase for IP.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT AddIpPerInterfaceBlocks(IInterfaceInfo *pIf, IInfoBase *pInfoBase)
{
HRESULT hr = hrOK;
BYTE* pInfo;
BYTE* pNewInfo = NULL;
DWORD dwErr;
DWORD dwSize;
CORg( pInfoBase->WriteTo(&pInfo, &dwSize) );
dwErr = MprConfigCreateIpInterfaceInfo(
pIf->GetInterfaceType(), pInfo, &pNewInfo );
CoTaskMemFree(pInfo);
if (dwErr != NO_ERROR) { return E_OUTOFMEMORY; }
dwSize = ((RTR_INFO_BLOCK_HEADER*)pNewInfo)->Size;
CORg( pInfoBase->LoadFrom(dwSize, pNewInfo) );
Error:
if (pNewInfo) { MprInfoDelete(pNewInfo); }
return hr;
}
/*!--------------------------------------------------------------------------
MprConfigCreateIpInterfaceInfo
Constructs an infobase containing required IP interface configuration.
The infobase should freed by calling 'MprInfoDelete'.
Author: AboladeG (based on AddIpPerInterfaceBlocks by KennT).
---------------------------------------------------------------------------*/
extern "C"
DWORD APIENTRY MprConfigCreateIpInterfaceInfo(DWORD dwIfType,
PBYTE ExistingHeader, PBYTE* NewHeader )
{
DWORD dwErr;
PBYTE Header = NULL;
if (ExistingHeader)
{
dwErr = MprInfoDuplicate(ExistingHeader, (VOID**)&Header);
}
else
{
dwErr = MprInfoCreate(RTR_INFO_BLOCK_VERSION, (VOID**)&Header);
}
if (dwErr) { return dwErr; }
do {
//
// Check that there is a block for interface-status in the info,
// and insert the default block if none is found.
//
if ( !MprInfoBlockExists(Header, IP_MCAST_HEARBEAT_INFO) )
{
dwErr =
MprInfoBlockAdd(
Header,
IP_MCAST_HEARBEAT_INFO,
sizeof(MCAST_HBEAT_INFO),
1,
g_pIpIfMulticastHeartbeatDefault,
(VOID**)NewHeader
);
if (dwErr) { break; }
MprInfoDelete(Header); Header = *NewHeader;
}
//
// Check that there is a block for multicast in the info,
// and insert the default block if none is found.
//
if ( !MprInfoBlockExists(Header, IP_INTERFACE_STATUS_INFO) )
{
dwErr =
MprInfoBlockAdd(
Header,
IP_INTERFACE_STATUS_INFO,
sizeof(INTERFACE_STATUS_INFO),
1,
g_pIpIfStatusDefault,
(VOID**)NewHeader
);
if (dwErr) { break; }
MprInfoDelete(Header); Header = *NewHeader;
}
//
// Check that there is a block for router-discovery,
// inserting the default block if none is found
//
if ( !MprInfoBlockExists(Header, IP_ROUTER_DISC_INFO) )
{
//
// Select the default configuration which is appropriate
// for the type of interface being configured (LAN/WAN)
//
BYTE *pDefault;
pDefault =
(dwIfType == ROUTER_IF_TYPE_DEDICATED)
? g_pRtrDiscLanDefault
: g_pRtrDiscWanDefault;
dwErr =
MprInfoBlockAdd(
Header,
IP_ROUTER_DISC_INFO,
sizeof(RTR_DISC_INFO),
1,
pDefault,
(VOID**)NewHeader
);
if (dwErr) { break; }
MprInfoDelete(Header); Header = *NewHeader;
}
*NewHeader = Header;
} while(FALSE);
if (dwErr) { MprInfoDelete(Header); *NewHeader = NULL; }
return dwErr;
}
/*!--------------------------------------------------------------------------
AddIpxPerInterfaceBlocks
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT AddIpxPerInterfaceBlocks(IInterfaceInfo *pIf, IInfoBase *pInfoBase)
{
HRESULT hr = hrOK;
#ifdef DEBUG
InfoBlock * pTestBlock;
#endif
//
// Check that there is a block for interface-status in the info,
// and insert the default block if none is found.
//
if (pInfoBase->BlockExists(IPX_INTERFACE_INFO_TYPE) == hrFalse)
{
IPX_IF_INFO ipx;
ipx.AdminState = ADMIN_STATE_ENABLED;
ipx.NetbiosAccept = ADMIN_STATE_DISABLED;
ipx.NetbiosDeliver = ADMIN_STATE_DISABLED;
CORg( pInfoBase->AddBlock(IPX_INTERFACE_INFO_TYPE,
sizeof(ipx),
(PBYTE) &ipx,
1 /* count */,
FALSE /* bRemoveFirst */) );
Assert( pInfoBase->GetBlock(IPX_INTERFACE_INFO_TYPE,
&pTestBlock, 0) == hrOK);
}
//
// Check that there is a block for WAN interface-status in the info,
// and insert the default block if none is found.
//
if (pInfoBase->BlockExists(IPXWAN_INTERFACE_INFO_TYPE) == hrFalse)
{
IPXWAN_IF_INFO ipxwan;
ipxwan.AdminState = ADMIN_STATE_DISABLED;
CORg( pInfoBase->AddBlock(IPXWAN_INTERFACE_INFO_TYPE,
sizeof(ipxwan),
(PBYTE) &ipxwan,
1 /* count */,
FALSE /* bRemoveFirst */) );
Assert( pInfoBase->GetBlock(IPXWAN_INTERFACE_INFO_TYPE,
&pTestBlock, 0) == hrOK);
}
// HACK! HACK!
// For IPX we have to add the RIP/SAP info blocks otherwise
// adding IPX to the interface will fail
// ----------------------------------------------------------------
if (!FHrOK(pInfoBase->BlockExists(IPX_PROTOCOL_RIP)))
{
// Add a RIP_IF_CONFIG block
BYTE * pDefault;
if (pIf->GetInterfaceType() == ROUTER_IF_TYPE_DEDICATED)
pDefault = g_pIpxRipLanInterfaceDefault;
else
pDefault = g_pIpxRipInterfaceDefault;
pInfoBase->AddBlock(IPX_PROTOCOL_RIP,
sizeof(RIP_IF_CONFIG),
pDefault,
1,
0);
}
if (!FHrOK(pInfoBase->BlockExists(IPX_PROTOCOL_SAP)))
{
// Add a SAP_IF_CONFIG block
BYTE * pDefault;
if (pIf->GetInterfaceType() == ROUTER_IF_TYPE_DEDICATED)
pDefault = g_pIpxSapLanInterfaceDefault;
else
pDefault = g_pIpxSapInterfaceDefault;
pInfoBase->AddBlock(IPX_PROTOCOL_SAP,
sizeof(SAP_IF_CONFIG),
pDefault,
1,
0);
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
UpdateLanaMapForDialinClients
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT UpdateLanaMapForDialinClients(LPCTSTR pszServerName, DWORD dwAllowNetworkAccess)
{
HRESULT hr = hrOK;
DWORD dwErr;
RegKey regkeyNetBIOS;
CStringList rgstBindList;
CByteArray rgLanaMap;
int i, cEntries;
UINT cchNdisWanNbfIn;
POSITION pos;
CString st;
BYTE bValue;
// Get to the NetBIOS key
// ----------------------------------------------------------------
dwErr = regkeyNetBIOS.Open(HKEY_LOCAL_MACHINE,
c_szRegKeyNetBIOSLinkage,
KEY_ALL_ACCESS,
pszServerName);
if (dwErr != ERROR_SUCCESS)
{
// Setup the registry error
// ------------------------------------------------------------
SetRegError(0, HResultFromWin32(dwErr),
IDS_ERR_REG_OPEN_CALL_FAILED,
c_szHKLM, c_szRegKeyNetBIOSLinkage, NULL);
goto Error;
}
// Get the BIND key (this is a multivalued string)
// ----------------------------------------------------------------
dwErr = regkeyNetBIOS.QueryValue(c_szBind, rgstBindList);
if (dwErr != ERROR_SUCCESS)
{
SetRegError(0, HResultFromWin32(dwErr),
IDS_ERR_REG_QUERYVALUE_CALL_FAILED,
c_szHKLM, c_szRegKeyNetBIOSLinkage, c_szBind, NULL);
goto Error;
}
// Get the LanaMap key (this is a byte array)
// ----------------------------------------------------------------
dwErr = regkeyNetBIOS.QueryValue(c_szRegValLanaMap, rgLanaMap);
if (dwErr != ERROR_SUCCESS)
{
SetRegError(0, HResultFromWin32(dwErr),
IDS_ERR_REG_QUERYVALUE_CALL_FAILED,
c_szHKLM, c_szRegKeyNetBIOSLinkage, c_szRegValLanaMap, NULL);
goto Error;
}
// Find the entries that prefix match the "Nbf_NdisWanNbfIn" string.
// Set the corresponding entries in the LanaMap key to
// 0 or 1 (entry value = !dwAllowNetworkAccess).
// ----------------------------------------------------------------
cEntries = rgstBindList.GetCount();
pos = rgstBindList.GetHeadPosition();
cchNdisWanNbfIn = StrLen(c_szDeviceNbfNdisWanNbfIn);
for (i=0; i<cEntries; i++)
{
st = rgstBindList.GetNext(pos);
if (st.IsEmpty())
continue;
if (StrnCmp((LPCTSTR) st, c_szDeviceNbfNdisWanNbfIn, cchNdisWanNbfIn) == 0)
{
// Set the appropriate bit in the byte array
// --------------------------------------------------------
// We set the value to the opposite of dwAllowNetworkAccess
// --------------------------------------------------------
bValue = (dwAllowNetworkAccess ? 0 : 1);
rgLanaMap.SetAt(2*i, bValue);
}
}
// Write the info back out to the LanaMap key
// ----------------------------------------------------------------
dwErr = regkeyNetBIOS.SetValue(c_szRegValLanaMap, rgLanaMap);
if (dwErr != ERROR_SUCCESS)
{
SetRegError(0, HResultFromWin32(dwErr),
IDS_ERR_REG_SETVALUE_CALL_FAILED,
c_szHKLM, c_szRegKeyNetBIOSLinkage, c_szRegValLanaMap, NULL);
goto Error;
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
HrIsProtocolSupported
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT HrIsProtocolSupported(LPCTSTR pszServerName,
LPCTSTR pszServiceKey,
LPCTSTR pszRasServiceKey,
LPCTSTR pszExtraKey)
{
HRESULT hr = hrFalse;
HRESULT hrTemp;
DWORD dwErr;
RegKey regkey;
HKEY hkeyMachine = NULL;
COM_PROTECT_TRY
{
CWRg( ConnectRegistry(pszServerName, &hkeyMachine) );
// Try to open both keys, if both succeed, then we
// consider the protocol to be installed.
// ------------------------------------------------------------
dwErr = regkey.Open(hkeyMachine, pszServiceKey, KEY_READ);
hrTemp = HResultFromWin32(dwErr);
if (FHrOK(hrTemp))
{
regkey.Close();
dwErr = regkey.Open(hkeyMachine, pszRasServiceKey, KEY_READ);
hrTemp = HResultFromWin32(dwErr);
// If pszExtraKey == NULL, then there is no extra key
// for us to test.
if (FHrOK(hrTemp) && pszExtraKey)
{
regkey.Close();
dwErr = regkey.Open(hkeyMachine, pszExtraKey, KEY_READ);
hrTemp = HResultFromWin32(dwErr);
}
}
// Both keys succeeded, so return hrOK
// ------------------------------------------------------------
if (FHrOK(hrTemp))
hr = hrOK;
else
hr = hrFalse;
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
if (hkeyMachine)
DisconnectRegistry(hkeyMachine);
return hr;
}
/*!--------------------------------------------------------------------------
RegisterRouterInDomain
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RegisterRouterInDomain(LPCTSTR pszRouterName, BOOL fRegister)
{
DOMAIN_CONTROLLER_INFO * pDcInfo = NULL;
HRESULT hr = hrOK;
HRESULT hrT = hrOK;
// If this fails, we assume this is standalone.
hrT = HrIsStandaloneServer(pszRouterName);
if (hrT == S_FALSE)
{
CWRg( DsGetDcName(pszRouterName, NULL, NULL, NULL, 0, &pDcInfo) );
CWRg( MprDomainRegisterRasServer(pDcInfo->DomainName,
(LPTSTR) pszRouterName,
fRegister) );
}
Error:
if (pDcInfo)
NetApiBufferFree(pDcInfo);
return hr;
}
/*!--------------------------------------------------------------------------
SetDeviceType
For the given machine, this API will set the ports for this
machine accordingly (given the dwRouterType).
If dwTotalPorts is non-zero, then the max ports for L2TP/PPTP
will be adjusted (each will get 1/2 of dwTotalPorts).
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetDeviceType(LPCTSTR pszMachineName,
DWORD dwRouterType,
DWORD dwTotalPorts)
{
PortsDataEntry portsDataEntry;
PortsDeviceList portsList;
PortsDeviceEntry * pEntry = NULL;
HRESULT hr = hrOK;
POSITION pos;
CORg( portsDataEntry.Initialize(pszMachineName) );
CORg( portsDataEntry.LoadDevices( &portsList ) );
CORg( SetDeviceTypeEx( &portsList, dwRouterType ) );
if (dwTotalPorts)
{
// Set the port sizes for L2TP and PPTP
CORg( SetPortSize(&portsList, dwTotalPorts/2) );
}
// Save the data back
// ----------------------------------------------------------------
CORg( portsDataEntry.SaveDevices( &portsList ) );
Error:
// Clear out the ports list, we don't need the data anymore
// ----------------------------------------------------------------
while (!portsList.IsEmpty())
delete portsList.RemoveHead();
return hr;
}
/*!--------------------------------------------------------------------------
SetPortSize
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetPortSize(PortsDeviceList *pDeviceList, DWORD dwPorts)
{
HRESULT hr = hrOK;
POSITION pos;
PortsDeviceEntry * pEntry = NULL;
pos = pDeviceList->GetHeadPosition();
while (pos)
{
pEntry = pDeviceList->GetNext(pos);
if ((RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_Pptp) ||
(RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Tunnel_L2tp))
{
pEntry->m_fModified = TRUE;
pEntry->m_dwPorts = dwPorts;
}
}
return hr;
}
/*!--------------------------------------------------------------------------
SetDeviceTypeEx
This is the core of the function above.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetDeviceTypeEx(PortsDeviceList *pDeviceList,
DWORD dwRouterType)
{
PortsDeviceEntry * pEntry = NULL;
HRESULT hr = hrOK;
POSITION pos;
Assert(pDeviceList);
Assert(dwRouterType);
// Ok now we go through and set the type of all of the devices
// ----------------------------------------------------------------
pos = pDeviceList->GetHeadPosition();
while (pos)
{
pEntry = pDeviceList->GetNext(pos);
// If we have enabled routing and if this port did not
// have routing enabled, enable routing.
// ------------------------------------------------------------
if ((dwRouterType & (ROUTER_TYPE_LAN | ROUTER_TYPE_WAN)))
{
if (!pEntry->m_dwEnableRouting)
{
pEntry->m_dwEnableRouting = TRUE;
pEntry->m_fModified = TRUE;
}
}
else
{
// If this port does NOT have routing enabled
// and routing is enabled, disable it.
// --------------------------------------------------------
if (pEntry->m_dwEnableRouting)
{
pEntry->m_dwEnableRouting = FALSE;
pEntry->m_fModified = TRUE;
}
}
// Windows NT Bug : 292615
// If this is a parallel port, do not enable RAS.
// ------------------------------------------------------------
if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_Parallel)
{
if (pEntry->m_dwEnableRas)
{
pEntry->m_dwEnableRas = FALSE;
pEntry->m_fModified = TRUE;
}
continue;
}
//
// For PPPoE devices disable Ras and Routing. Only outbound
// routing can be set for PPPoE devices
if (RAS_DEVICE_TYPE(pEntry->m_eDeviceType) == RDT_PPPoE)
{
if (pEntry->m_dwEnableRas)
{
pEntry->m_dwEnableRas = FALSE;
pEntry->m_fModified = TRUE;
}
if (pEntry->m_dwEnableRouting)
{
pEntry->m_dwEnableRouting = FALSE;
pEntry->m_fModified = TRUE;
}
continue;
}
// Similarly for RAS
// ------------------------------------------------------------
if (dwRouterType & ROUTER_TYPE_RAS)
{
if (!pEntry->m_dwEnableRas)
{
pEntry->m_dwEnableRas = TRUE;
pEntry->m_fModified = TRUE;
}
}
else
{
if (pEntry->m_dwEnableRas)
{
pEntry->m_dwEnableRas = FALSE;
pEntry->m_fModified = TRUE;
}
}
}
return hr;
}
HRESULT SetRouterInstallRegistrySettings(LPCWSTR pswzServer,
BOOL fInstall,
BOOL fChangeEnableRouter)
{
HRESULT hr = hrOK;
HKEY hklm = NULL;
CWRg( ConnectRegistry(pswzServer, &hklm) );
// Write out the global registry settings
CORg( SetGlobalRegistrySettings(hklm, fInstall, fChangeEnableRouter) );
// Write the per-interface registry settings
CORg( SetPerInterfaceRegistrySettings(hklm, fInstall) );
Error:
if (hklm)
{
DisconnectRegistry(hklm);
hklm = NULL;
}
return hr;
}
static CString s_PortDeviceTypeModem;
static CString s_PortDeviceTypeX25;
static CString s_PortDeviceTypeIsdn;
static CString s_PortDeviceTypeSerial;
static CString s_PortDeviceTypeFrameRelay;
static CString s_PortDeviceTypeAtm;
static CString s_PortDeviceTypeSonet;
static CString s_PortDeviceTypeSw56;
static CString s_PortDeviceTypePptp;
static CString s_PortDeviceTypeL2tp;
static CString s_PortDeviceTypeIrda;
static CString s_PortDeviceTypeParallel;
static CString s_PortDeviceTypePPPoE;
static CString s_PortDeviceTypeOther;
static const CStringMapEntry s_PortTypeMap[] =
{
{ RDT_Modem, &s_PortDeviceTypeModem, IDS_PORTSDLG_DEVTYPE_MODEM },
{ RDT_X25, &s_PortDeviceTypeX25, IDS_PORTSDLG_DEVTYPE_X25 },
{ RDT_Isdn, &s_PortDeviceTypeIsdn, IDS_PORTSDLG_DEVTYPE_ISDN },
{ RDT_Serial, &s_PortDeviceTypeSerial, IDS_PORTSDLG_DEVTYPE_SERIAL },
{ RDT_FrameRelay, &s_PortDeviceTypeFrameRelay, IDS_PORTSDLG_DEVTYPE_FRAMERELAY },
{ RDT_Atm, &s_PortDeviceTypeAtm, IDS_PORTSDLG_DEVTYPE_ATM },
{ RDT_Sonet, &s_PortDeviceTypeSonet, IDS_PORTSDLG_DEVTYPE_SONET },
{ RDT_Sw56, &s_PortDeviceTypeSw56, IDS_PORTSDLG_DEVTYPE_SW56 },
{ RDT_Tunnel_Pptp, &s_PortDeviceTypePptp, IDS_PORTSDLG_DEVTYPE_PPTP },
{ RDT_Tunnel_L2tp, &s_PortDeviceTypeL2tp, IDS_PORTSDLG_DEVTYPE_L2TP },
{ RDT_Irda, &s_PortDeviceTypeIrda, IDS_PORTSDLG_DEVTYPE_IRDA },
{ RDT_Parallel, &s_PortDeviceTypeParallel, IDS_PORTSDLG_DEVTYPE_PARALLEL },
{ RDT_PPPoE, &s_PortDeviceTypePPPoE, IDS_PORTSDLG_DEVTYPE_PPPOE },
{ RDT_Other, &s_PortDeviceTypeOther, IDS_PORTSDLG_DEVTYPE_OTHER },
{ -1, &s_PortUnknown, IDS_PORT_UNKNOWN },
};
/*!--------------------------------------------------------------------------
PortTypeToCString
-
Author: MikeG (a-migall)
---------------------------------------------------------------------------*/
CString& PortTypeToCString(DWORD dwPortType)
{
// Make sure that the class info has been "stripped" from the port
// type mask.
DWORD dw = static_cast<DWORD>(RAS_DEVICE_TYPE(dwPortType));
// For now, if we don't know what the type is we'll default to "Other"
// as an answer. FUTURE: Someone may want to change this in the future.
if (dw > RDT_Other)
dw = RDT_Other;
return MapDWORDToCString(dwPortType, s_PortTypeMap);
}
/*---------------------------------------------------------------------------
CWaitForRemoteAccessDlg implementation
---------------------------------------------------------------------------*/
CWaitForRemoteAccessDlg::CWaitForRemoteAccessDlg(LPCTSTR pszServerName,
LPCTSTR pszText, LPCTSTR pszTitle, CWnd *pParent)
: CWaitDlg(pszServerName, pszText, pszTitle, pParent)
{
}
void CWaitForRemoteAccessDlg::OnTimerTick()
{
HRESULT hr = hrOK;
DWORD dwErrorCode = ERROR_SUCCESS;
// Windows NT Bug : 266364
// 266364 - If we got this far we assume that the service has
// already started, but it may then exit out after that point (due
// to some other configuration error). So we need to check to see
// if the service is running.
hr = IsRouterServiceRunning(m_strServerName, &dwErrorCode);
if (FHrOK(hr))
{
if (MprAdminIsServiceRunning(T2W((LPTSTR)(LPCTSTR) m_strServerName)) == TRUE)
CDialog::OnOK();
// If the service is running, but MprAdmin is not finished yet,
// party on.
}
else
{
// Stop the timer
CloseTimer();
CDialog::OnOK();
// Ensure that an error info was created
CreateTFSErrorInfo(NULL);
// The service is not running. We can exit out of this dialog.
// An error may have occurred, if we have the error code, report
// the error.
if (dwErrorCode != ERROR_SUCCESS)
{
TCHAR szBuffer[2048];
AddHighLevelErrorStringId(IDS_ERR_SERVICE_FAILED_TO_START);
FormatSystemError(dwErrorCode,
szBuffer,
DimensionOf(szBuffer),
0,
FSEFLAG_SYSMESSAGE | FSEFLAG_MPRMESSAGE);
FillTFSError(0, HResultFromWin32(dwErrorCode), FILLTFSERR_LOW,
0, szBuffer, 0);
DisplayTFSErrorMessage(GetSafeHwnd());
}
else
{
AddHighLevelErrorStringId(IDS_ERR_SERVICE_FAILED_TO_START_UNKNOWN);
}
}
}
/////////////////////////////////////////////////////////////////////////////
// CRestartRouterDlg dialog
CRestartRouterDlg::CRestartRouterDlg
(
LPCTSTR pszServerName,
LPCTSTR pszText,
LPCTSTR pszTitle,
CTime* pTimeStart,
CWnd* pParent /*= NULL*/
)
: CWaitDlg(pszServerName, pszText, pszTitle, pParent)
{
m_pTimeStart = pTimeStart;
m_dwTimeElapsed = 0;
m_fTimeOut = FALSE;
m_dwError = NO_ERROR;
}
void CRestartRouterDlg::OnTimerTick()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_dwTimeElapsed++;
if (!(m_dwTimeElapsed % TIMEOUT_POLL))
{
HRESULT hr = hrOK;
DWORD dwError = NO_ERROR;
DWORD dwServiceStatus = 0;
BOOL fFinished = FALSE;
hr = GetRouterServiceStatus((LPCTSTR)m_strServerName, &dwServiceStatus, &dwError);
if (FHrSucceeded(hr) && SERVICE_RUNNING == dwServiceStatus)
{
USES_CONVERSION;
if (MprAdminIsServiceRunning(T2W((LPTSTR)((LPCTSTR)m_strServerName))))
{
DWORD dwUpTime;
dwError = GetRouterUpTime(m_strServerName, &dwUpTime);
if (NO_ERROR == dwError &&
dwUpTime <= (DWORD) ((CTime::GetCurrentTime() - *m_pTimeStart).GetTotalSeconds()))
{
CDialog::OnOK();
fFinished = TRUE;
m_fTimeOut = FALSE;
}
}
}
if (NO_ERROR != dwError)
{
CDialog::OnOK();
m_dwError = dwError;
}
//NTBUG: ID=249775. The behavior of this dialog has to be same as the start
// dialog. So, timeout feature is disabled.
/*
//if the waiting time has been longer to 60 seconds, we assume someting is wrong
else if (!fFinished &&
(CTime::GetCurrentTime() - *m_pTimeStart).GetTotalSeconds() > MAX_WAIT_RESTART)
{
CDialog::OnOK();
m_fTimeOut = TRUE;
}
*/
}
}
TFSCORE_API(HRESULT) PauseRouterService(LPCWSTR pszMachine)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
CString stServiceDesc;
DWORD dwErr;
COM_PROTECT_TRY
{
// Load the description for the SAP Agent
stServiceDesc.LoadString(IDS_SAPAGENT_SERVICE_DESC);
// Pause the SAP Agent
// ------------------------------------------------------------
dwErr = TFSPauseService(pszMachine,
c_szNWSAPAgent,
stServiceDesc);
if ((dwErr == ERROR_SERVICE_NOT_ACTIVE) ||
(dwErr == ERROR_SERVICE_DOES_NOT_EXIST))
hr = hrOK;
else
CWRg( dwErr );
// Load the description for the router
// ------------------------------------------------------------
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
// Pause the router service
// ------------------------------------------------------------
dwErr = TFSPauseService(pszMachine,
c_szRouter,
stServiceDesc);
if ((dwErr == ERROR_SERVICE_NOT_ACTIVE) ||
(dwErr == ERROR_SERVICE_DOES_NOT_EXIST))
hr = hrOK;
else
CWRg( dwErr );
// Pause the RemoteAccess service
// ------------------------------------------------------------
dwErr = TFSPauseService(pszMachine,
c_szRemoteAccess,
stServiceDesc);
if ((dwErr == ERROR_SERVICE_NOT_ACTIVE) ||
(dwErr == ERROR_SERVICE_DOES_NOT_EXIST))
hr = hrOK;
else
CWRg( dwErr );
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
TFSCORE_API(HRESULT) ResumeRouterService(LPCWSTR pszMachine)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
CString stServiceDesc;
DWORD dwErr;
COM_PROTECT_TRY
{
// Load the description for the SAP Agent
stServiceDesc.LoadString(IDS_SAPAGENT_SERVICE_DESC);
// Resume the SAP Agent
// ------------------------------------------------------------
dwErr = TFSResumeService(pszMachine,
c_szNWSAPAgent,
stServiceDesc);
if (dwErr == ERROR_SERVICE_NOT_ACTIVE)
hr = hrOK;
else
hr = HResultFromWin32(dwErr);
// Load the description for the router
// ------------------------------------------------------------
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
// Resume the router service
// ------------------------------------------------------------
dwErr = TFSResumeService(pszMachine,
c_szRouter,
stServiceDesc);
if (dwErr == ERROR_SERVICE_NOT_ACTIVE)
hr = hrOK;
else
hr = HResultFromWin32(dwErr);
// Resume the RemoteAccess service
// ------------------------------------------------------------
dwErr = TFSResumeService(pszMachine,
c_szRemoteAccess,
stServiceDesc);
if (dwErr == ERROR_SERVICE_NOT_ACTIVE)
hr = hrOK;
else
hr = HResultFromWin32(dwErr);
}
COM_PROTECT_CATCH;
return hr;
}
/*---------------------------------------------------------------------------
CNetConnection
---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
Class : CNetConnection
This class maintains a list of net connections (those connected using
WNetAddConnection2).
When told, it will release all of its connections.
---------------------------------------------------------------------------*/
class CNetConnection
{
public:
CNetConnection();
~CNetConnection();
HRESULT Add(LPCTSTR pszConnection);
HRESULT RemoveAll();
HRESULT Remove(LPCTSTR pszConnection);
private:
CStringList m_listConnections;
};
CNetConnection::CNetConnection()
{
}
CNetConnection::~CNetConnection()
{
RemoveAll();
}
HRESULT CNetConnection::Add(LPCTSTR pszConnection)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_listConnections.AddTail(pszConnection);
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT CNetConnection::Remove(LPCTSTR pszConnection)
{
HRESULT hr = hrOK;
POSITION p;
COM_PROTECT_TRY
{
p = m_listConnections.Find(pszConnection);
if ( p )
{
m_listConnections.RemoveAt(p);
WNetCancelConnection2(pszConnection,
0 /* dwFlags */,
TRUE /* fForce */);
}
}
COM_PROTECT_CATCH;
return hr;
}
HRESULT CNetConnection::RemoveAll()
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
while (!m_listConnections.IsEmpty())
{
CString st;
st = m_listConnections.RemoveHead();
WNetCancelConnection2((LPCTSTR) st,
0 /* dwFlags */,
TRUE /* fForce */);
}
}
COM_PROTECT_CATCH;
return hr;
}
// Global functions to add/remove net connections
// --------------------------------------------------------------------
static CNetConnection g_NetConnections;
HRESULT AddNetConnection(LPCTSTR pszConnection)
{
return g_NetConnections.Add(pszConnection);
}
HRESULT RemoveAllNetConnections()
{
return g_NetConnections.RemoveAll();
}
HRESULT RemoveNetConnection(LPCTSTR szServerName)
{
//Make the connection name
CString stIPCShare;
CString stRouterName = szServerName;
if ( stRouterName.Left(2) != TEXT( "\\\\" ) )
{
stIPCShare = TEXT( "\\\\" );
}
stIPCShare += stRouterName;
stIPCShare += TEXT( "\\" );
stIPCShare += c_szIPCShare;
return g_NetConnections.Remove(stIPCShare);
}
/*!--------------------------------------------------------------------------
RefreshMprConfig
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RefreshMprConfig(LPCTSTR pszServerName)
{
HRESULT hr = hrOK;
SPMprConfigHandle sphConfig;
CWRg( ::MprConfigServerConnect((LPWSTR) pszServerName,
&sphConfig) );
MprConfigServerRefresh(sphConfig);
Error:
return hr;
}
HRESULT WINAPI
IsWindows64Bit( LPCWSTR pwszMachine,
LPCWSTR pwszUserName,
LPCWSTR pwszPassword,
LPCWSTR pwszDomain,
BOOL * pf64Bit)
{
HRESULT hr = S_OK;
RouterVersionInfo routerVersion;
IWbemLocator * pIWbemLocator = NULL;
IWbemServices * pIWbemServices = NULL;
SEC_WINNT_AUTH_IDENTITY_W stAuthIdentity;
HKEY hkeyMachine = NULL;
*pf64Bit = FALSE;
//Check to see if the version is <= 2195. If yes then there is no 64 bit there...
if (ERROR_SUCCESS == ConnectRegistry(pwszMachine, &hkeyMachine))
QueryRouterVersionInfo(hkeyMachine, &routerVersion);
if (hkeyMachine)
DisconnectRegistry(hkeyMachine);
if ( routerVersion.dwOsBuildNo <= RASMAN_PPP_KEY_LAST_WIN2k_VERSION )
{
return hr;
}
hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
if (FAILED(hr) && (RPC_E_CHANGED_MODE != hr))
{
return hr;
}
// Create an instance of the WbemLocator interface.
hr = CoCreateInstance( CLSID_WbemLocator,
NULL,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID *) &pIWbemLocator
);
if (hrOK != hr)
{
return hr;
}
// Using the locator, connect to CIMOM in the given namespace.
BSTR pNamespace;
WCHAR szPath[MAX_PATH];
WCHAR szTemp[MAX_PATH];
BSTR bstrUserName = NULL, bstrPassword = NULL, bstrDomain = NULL;
if ( pwszUserName )
{
bstrUserName = SysAllocString(pwszUserName);
if ( pwszPassword )
bstrPassword = SysAllocString(pwszPassword);
if ( pwszDomain )
{
wsprintf ( szTemp, L"NTLMDOMAIN:%s", pwszDomain );
bstrDomain = SysAllocString(szTemp);
}
}
wsprintf(szPath, L"\\\\%s\\root\\cimv2", !pwszMachine ? L"." : pwszMachine);
pNamespace = SysAllocString(szPath);
hr = pIWbemLocator->ConnectServer( pNamespace,
(pwszUserName?bstrUserName:NULL), //UserName
(pwszPassword?bstrPassword:NULL), //Password
0L, // locale
0L, // securityFlags
( pwszDomain?bstrDomain:NULL), // authority (domain for NTLM)
NULL, // context
&pIWbemServices);
if (SUCCEEDED(hr))
{
if ( pwszUserName )
{
ZeroMemory ( &stAuthIdentity, sizeof(stAuthIdentity));
stAuthIdentity.User = (LPWSTR)pwszUserName;
stAuthIdentity.UserLength = lstrlenW(pwszUserName );
stAuthIdentity.Password = (LPWSTR)pwszPassword;
stAuthIdentity.PasswordLength = lstrlenW( pwszPassword );
if ( pwszDomain )
{
stAuthIdentity.Domain = (LPWSTR)pwszDomain;
stAuthIdentity.DomainLength = lstrlenW(pwszDomain);
}
stAuthIdentity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
}
hr = CoSetProxyBlanket(pIWbemServices,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE,
NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
(pwszUserName?&stAuthIdentity:NULL),
EOAC_NONE);
if (SUCCEEDED(hr))
{
IEnumWbemClassObject * pEnum = NULL;
BSTR bstrWQL = SysAllocString(L"WQL");
VARIANT varArchitecture;
BSTR bstrPath;
bstrPath = SysAllocString(L"select * from Win32_Processor");
hr = pIWbemServices->ExecQuery(bstrWQL, bstrPath, WBEM_FLAG_FORWARD_ONLY, NULL, &pEnum);
if (SUCCEEDED(hr))
{
hr = CoSetProxyBlanket(pEnum,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE,
NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
(pwszUserName?&stAuthIdentity:NULL),
EOAC_NONE);
if ( SUCCEEDED(hr) )
{
IWbemClassObject *pNSClass;
ULONG uReturned;
pEnum->Next(WBEM_INFINITE, 1, &pNSClass, &uReturned );
if (SUCCEEDED(hr))
{
if (uReturned)
{
CIMTYPE ctpeType;
hr = pNSClass->Get(L"Architecture", NULL, &varArchitecture, &ctpeType, NULL);
if (SUCCEEDED(hr))
{
VariantChangeType(&varArchitecture, &varArchitecture, 0, VT_UINT);
if ( varArchitecture.uintVal == 6 ) //64 bit
{
*pf64Bit = TRUE;
}
}
}
else
{
hr = E_UNEXPECTED;
}
pNSClass->Release();
}
}
pEnum->Release();
}
SysFreeString(bstrPath);
SysFreeString(bstrWQL);
pIWbemServices->Release();
}
pIWbemLocator->Release();
if ( bstrUserName ) SysFreeString(bstrUserName);
if ( bstrPassword ) SysFreeString(bstrPassword);
if ( bstrDomain ) SysFreeString(bstrDomain);
}
SysFreeString(pNamespace);
CoUninitialize();
// Translate any WMI errors into Win32 errors:
switch (hr)
{
case WBEM_E_NOT_FOUND:
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
break;
case WBEM_E_ACCESS_DENIED:
hr = E_ACCESSDENIED;
break;
case WBEM_E_PROVIDER_FAILURE:
hr = E_FAIL;
break;
case WBEM_E_TYPE_MISMATCH:
case WBEM_E_INVALID_CONTEXT:
case WBEM_E_INVALID_PARAMETER:
hr = E_INVALIDARG;
break;
case WBEM_E_OUT_OF_MEMORY:
hr = E_OUTOFMEMORY;
break;
}
return hr;
}
HRESULT WINAPI TransferCredentials ( IRouterInfo * pRISource,
IRouterInfo * pRIDest
)
{
HRESULT hr = S_OK;
SPIRouterAdminAccess spAdminSrc;
SPIRouterAdminAccess spAdminDest;
SPIRouterInfo spRISource;
SPIRouterInfo spRIDest;
PBYTE pbPassword = NULL;
int nPasswordLen = 0;
COM_PROTECT_TRY
{
spRISource.Set(pRISource);
spRIDest.Set(pRIDest);
spAdminSrc.HrQuery(spRISource);
spAdminDest.HrQuery(spRIDest);
if (spAdminSrc && spAdminSrc->IsAdminInfoSet() && spAdminDest)
{
spAdminSrc->GetUserPassword(NULL, &nPasswordLen );
pbPassword = (PBYTE) new BYTE [nPasswordLen];
spAdminSrc->GetUserPassword( pbPassword, &nPasswordLen );
spAdminDest->SetInfo( spAdminSrc->GetUserName(),
spAdminSrc->GetDomainName(),
pbPassword,
nPasswordLen
);
delete pbPassword;
}
}
COM_PROTECT_CATCH;
return hr;
}
Reference in a new issue View git blame Copy permalink