archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/net/mmc/rtrlib/rtrcomn.cpp

524 lines
14 KiB
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
rtrcomn.cpp
FILE HISTORY:
*/
#include "stdafx.h"
#include "tfschar.h"
#include "info.h"
#include "rtrstr.h"
#include "rtrcomn.h"
#include "rtrguid.h"
#include "mprapi.h"
#include "rtrutil.h"
#include "lsa.h"
#include "tregkey.h"
#include "reg.h"
/*---------------------------------------------------------------------------
Function: IfInterfaceIdHasIpxExtensions
Checks the string to see if it has the following extensions
EthernetSNAP
EthernetII
Ethernet802.2
Ethernet802.3
---------------------------------------------------------------------------*/
int IfInterfaceIdHasIpxExtensions(LPCTSTR pszIfId)
{
CString stIfEnd;
CString stIf = pszIfId;
BOOL bFound = TRUE;
int iPos = 0;
do
{
stIfEnd = stIf.Right(lstrlen(c_szEthernetII));
if (stIfEnd == c_szEthernetII)
break;
stIfEnd = stIf.Right(lstrlen(c_szEthernetSNAP));
if (stIfEnd == c_szEthernetSNAP)
break;
stIfEnd = stIf.Right(lstrlen(c_szEthernet8022));
if (stIfEnd == c_szEthernet8022)
break;
stIfEnd = stIf.Right(lstrlen(c_szEthernet8023));
if (stIfEnd == c_szEthernet8023)
break;
bFound = FALSE;
}
while (FALSE);
if (bFound)
iPos = stIf.GetLength() - stIfEnd.GetLength();
return iPos;
}
extern const GUID CLSID_RemoteRouterConfig;
HRESULT CoCreateRouterConfig(LPCTSTR pszMachine,
IRouterInfo *pRouter,
COSERVERINFO *pcsi,
const GUID& riid,
IUnknown **ppUnk)
{
HRESULT hr = hrOK;
MULTI_QI qi;
Assert(ppUnk);
*ppUnk = NULL;
if (IsLocalMachine(pszMachine))
{
hr = CoCreateInstance(CLSID_RemoteRouterConfig,
NULL,
CLSCTX_SERVER | CLSCTX_ENABLE_CODE_DOWNLOAD,
riid,
(LPVOID *) &(qi.pItf));
}
else
{
SPIRouterAdminAccess spAdmin;
BOOL fAdminInfoSet = FALSE;
COSERVERINFO csi;
Assert(pcsi);
qi.pIID = &riid;
qi.pItf = NULL;
qi.hr = 0;
pcsi->dwReserved1 = 0;
pcsi->dwReserved2 = 0;
pcsi->pwszName = (LPWSTR) (LPCTSTR) pszMachine;
if (pRouter)
{
spAdmin.HrQuery(pRouter);
if (spAdmin && spAdmin->IsAdminInfoSet())
{
int cPassword;
int cchPassword;
WCHAR * pszPassword = NULL;
UCHAR ucSeed = 0x83;
pcsi->pAuthInfo->dwAuthnSvc = RPC_C_AUTHN_WINNT;
pcsi->pAuthInfo->dwAuthzSvc = RPC_C_AUTHZ_NONE;
pcsi->pAuthInfo->pwszServerPrincName = NULL;
pcsi->pAuthInfo->dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT;
pcsi->pAuthInfo->dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
// pcsi->pAuthInfo->pAuthIdentityData = &caid;
pcsi->pAuthInfo->dwCapabilities = EOAC_NONE;
if (spAdmin->GetUserName())
{
pcsi->pAuthInfo->pAuthIdentityData->User = (LPTSTR) spAdmin->GetUserName();
pcsi->pAuthInfo->pAuthIdentityData->UserLength = StrLenW(spAdmin->GetUserName());
}
if (spAdmin->GetDomainName())
{
pcsi->pAuthInfo->pAuthIdentityData->Domain = (LPTSTR) spAdmin->GetDomainName();
pcsi->pAuthInfo->pAuthIdentityData->DomainLength = StrLenW(spAdmin->GetDomainName());
}
spAdmin->GetUserPassword(NULL, &cPassword);
// Assume that the password is Unicode
cchPassword = cPassword / sizeof(WCHAR);
pszPassword = (WCHAR *) new BYTE[cPassword + sizeof(WCHAR)];
spAdmin->GetUserPassword((PBYTE) pszPassword, &cPassword);
pszPassword[cchPassword] = 0;
RtlDecodeW(ucSeed, pszPassword);
delete pcsi->pAuthInfo->pAuthIdentityData->Password;
pcsi->pAuthInfo->pAuthIdentityData->Password = pszPassword;
pcsi->pAuthInfo->pAuthIdentityData->PasswordLength = cchPassword;
pcsi->pAuthInfo->pAuthIdentityData->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
fAdminInfoSet = TRUE;
}
else
{
pcsi->pAuthInfo = NULL;
}
}
hr = CoCreateInstanceEx(CLSID_RemoteRouterConfig,
NULL,
CLSCTX_SERVER | CLSCTX_ENABLE_CODE_DOWNLOAD,
pcsi,
1,
&qi);
if (FHrOK(hr) && fAdminInfoSet)
{
DWORD dwAuthnSvc, dwAuthzSvc, dwAuthnLevel, dwImpLevel;
DWORD dwCaps;
OLECHAR * pszServerPrincipal = NULL;
CComPtr<IUnknown> spIUnk;
qi.pItf->QueryInterface(IID_IUnknown, (void**)&spIUnk);
CoQueryProxyBlanket(spIUnk,
&dwAuthnSvc,
&dwAuthzSvc,
&pszServerPrincipal,
&dwAuthnLevel,
&dwImpLevel,
NULL,
&dwCaps);
hr = CoSetProxyBlanket(spIUnk,
dwAuthnSvc,
dwAuthzSvc,
pszServerPrincipal,
dwAuthnLevel,
dwImpLevel,
(RPC_AUTH_IDENTITY_HANDLE) pcsi->pAuthInfo->pAuthIdentityData,
dwCaps);
CoTaskMemFree(pszServerPrincipal);
pszServerPrincipal = NULL;
CoQueryProxyBlanket(qi.pItf,
&dwAuthnSvc,
&dwAuthzSvc,
&pszServerPrincipal,
&dwAuthnLevel,
&dwImpLevel,
NULL,
&dwCaps);
hr = CoSetProxyBlanket(qi.pItf,
dwAuthnSvc,
dwAuthzSvc,
pszServerPrincipal,
dwAuthnLevel,
dwImpLevel,
(RPC_AUTH_IDENTITY_HANDLE) pcsi->pAuthInfo->pAuthIdentityData,
dwCaps);
CoTaskMemFree(pszServerPrincipal);
}
}
if (FHrSucceeded(hr))
{
*ppUnk = qi.pItf;
qi.pItf = NULL;
}
return hr;
}
/*!--------------------------------------------------------------------------
CoCreateProtocolConfig
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT CoCreateProtocolConfig(const GUID& iid,
IRouterInfo *pRouter,
DWORD dwTransportId,
DWORD dwProtocolId,
IRouterProtocolConfig **ppConfig)
{
HRESULT hr = hrOK;
GUID guidConfig;
guidConfig = iid;
if (((iid == GUID_RouterNull) ||
(iid == GUID_RouterError)) &&
pRouter)
{
RouterVersionInfo routerVersion;
pRouter->GetRouterVersionInfo(&routerVersion);
// If we don't have a configuration GUID and this is an NT4
// router, then we create the default configuration object
// and use that to add/remove a protocol
// ------------------------------------------------------------
if ((routerVersion.dwRouterVersion <= 4) &&
(dwTransportId == PID_IP))
{
// For NT4, we have to create our own object
// --------------------------------------------------------
guidConfig = CLSID_IPRouterConfiguration;
}
}
if (guidConfig == GUID_RouterNull)
{
// Skip the rest of the creation, we didn't supply a GUID
// ------------------------------------------------------------
goto Error;
}
if (guidConfig == GUID_RouterError)
{
// We don't have a valid GUID
// ------------------------------------------------------------
CWRg( ERROR_BADKEY );
}
hr = CoCreateInstance(guidConfig,
NULL,
CLSCTX_INPROC_SERVER | CLSCTX_ENABLE_CODE_DOWNLOAD,
IID_IRouterProtocolConfig,
(LPVOID *) ppConfig);
CORg( hr );
Error:
return hr;
}
//----------------------------------------------------------------------------
// Function: QueryIpAddressList(
//
// Loads a list of strings with the IP addresses configured
// for a given LAN interface, if any.
//----------------------------------------------------------------------------
HRESULT
QueryIpAddressList(
IN LPCTSTR pszMachine,
IN HKEY hkeyMachine,
IN LPCTSTR pszInterface,
OUT CStringList* pAddressList,
OUT CStringList* pNetmaskList,
OUT BOOL * pfDhcpObtained,
OUT BOOL * pfDns,
OUT CString * pDhcpServer
) {
DWORD dwErr = NO_ERROR;
BOOL bDisconnect = FALSE;
RegKey regkeyMachine;
RegKey regkeyInterface;
DWORD dwType, dwSize, dwEnableDHCP;
SPBYTE spValue;
HRESULT hr = hrOK;
HKEY hkeyInterface;
INT i;
TCHAR* psz;
LPCTSTR aszSources[2];
CStringList* alistDestinations[2] = { pAddressList, pNetmaskList };
CString stNameServer;
LPCTSTR pszNameServer = NULL;
if (!pszInterface || !lstrlen(pszInterface) ||
!pAddressList || !pNetmaskList)
CORg(E_INVALIDARG);
//
// If no HKEY_LOCAL_MACHINE key was given, get one
//
if (hkeyMachine == NULL)
{
CWRg( ConnectRegistry(pszMachine, &hkeyMachine) );
regkeyMachine.Attach(hkeyMachine);
}
//
// Connect to the LAN card's registry key
//
CWRg( OpenTcpipInterfaceParametersKey(pszMachine, pszInterface,
hkeyMachine, &hkeyInterface) );
regkeyInterface.Attach(hkeyInterface);
//
// Read the 'EnableDHCP' flag to see whether to read
// the 'DhcpIPAddress' or the 'IPAddress'.
//
dwErr = regkeyInterface.QueryValue( c_szEnableDHCP, dwEnableDHCP );
if (dwErr == ERROR_SUCCESS)
{
if (pfDhcpObtained)
*pfDhcpObtained = dwEnableDHCP;
}
else
dwEnableDHCP = FALSE;
//
// If the flag isn't found, we look for the IP address;
// otherwise, we look for the setting indicated by the flag
//
if (dwErr == ERROR_SUCCESS && dwEnableDHCP)
{
//
// Read the 'DhcpIpAddress' and 'DhcpSubnetMask'
//
aszSources[0] = c_szDhcpIpAddress;
aszSources[1] = c_szDhcpSubnetMask;
pszNameServer = c_szRegValDhcpNameServer;
}
else
{
//
// Read the 'IPAddress' and 'SubnetMask'
//
aszSources[0] = c_szIPAddress;
aszSources[1] = c_szSubnetMask;
pszNameServer= c_szRegValNameServer;
}
if (pDhcpServer)
{
pDhcpServer->Empty();
regkeyInterface.QueryValue(c_szRegValDhcpServer, *pDhcpServer);
}
// Check the DhcpNameServer/NameServer to find the existence
// of DNS servers
if (pfDns)
{
regkeyInterface.QueryValue(pszNameServer, stNameServer);
stNameServer.TrimLeft();
stNameServer.TrimRight();
*pfDns = !stNameServer.IsEmpty();
}
//
// Read the address list and the netmask list
//
for (i = 0; i < 2 && dwErr == NO_ERROR; i++)
{
//
// Get the size of the multi-string-list
//
dwErr = regkeyInterface.QueryTypeAndSize(aszSources[i],
&dwType, &dwSize);
// CheckRegQueryValueError(dwErr, (LPCTSTR) c_szTcpip, aszSources[i], _T("QueryIpAddressList"));
CWRg( dwErr );
//
// Allocate space for the list
//
spValue = new BYTE[dwSize + sizeof(TCHAR)];
Assert(spValue);
::ZeroMemory(spValue, dwSize + sizeof(TCHAR));
//
// Read the list
//
dwErr = regkeyInterface.QueryValue(aszSources[i], (LPTSTR) (BYTE *)spValue, dwSize,
FALSE /* fExpandSz */);
// CheckRegQueryValueError(dwErr, (LPCTSTR) c_szTcpip, aszSources[i], _T("QueryIpAddressList"));
CWRg( dwErr );
//
// Fill the CString list with items
//
for (psz = (TCHAR*)(BYTE *)spValue; *psz; psz += lstrlen(psz) + 1)
{
alistDestinations[i]->AddTail(psz);
}
spValue.Free();
dwErr = NO_ERROR;
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
OpenTcpipInterfaceParametersKey
-
Author: KennT
---------------------------------------------------------------------------*/
DWORD OpenTcpipInterfaceParametersKey(LPCTSTR pszMachine,
LPCTSTR pszInterface,
HKEY hkeyMachine,
HKEY *phkeyParams)
{
DWORD dwErr;
BOOL fNt4;
CString skey;
dwErr = IsNT4Machine(hkeyMachine, &fNt4);
if (dwErr != ERROR_SUCCESS)
return dwErr;
//$NT5 : kennt, the tcpip key is stored separately. What they
// have done is to reverse the hierarchy, instead of a tcpip key
// under interfaces, there are now interfaces under tcpip
// the key location is
// HKLM\System\CCS\Services\Tcpip\Parameters\Interfaces\{interface}
// In NT4, this was
// HKLM\System\CCS\Services\{interface}\Parameters\Tcpip
// Need to determine if the target machine is running NT5 or not
if (fNt4)
{
skey = c_szSystemCCSServices;
skey += TEXT('\\');
skey += pszInterface;
skey += TEXT('\\');
skey += c_szParameters;
skey += TEXT('\\');
skey += c_szTcpip;
}
else
{
skey = c_szSystemCCSServices;
skey += TEXT('\\');
skey += c_szTcpip;
skey += TEXT('\\');
skey += c_szParameters;
skey += TEXT('\\');
skey += c_szInterfaces;
skey += TEXT('\\');
skey += pszInterface;
}
if (dwErr == ERROR_SUCCESS)
{
dwErr = ::RegOpenKeyEx(
hkeyMachine, skey, 0, KEY_ALL_ACCESS, phkeyParams);
// CheckRegOpenError(dwErr, (LPCTSTR) skey, _T("OpenTcpInterfaceParametersKey"));
}
return dwErr;
}