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.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/net/mmc/wins/winssup.cpp

1621 lines
42 KiB
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
winsup.cpp
Global functions
FILE HISTORY:
*/
#include "stdafx.h"
#include "winssup.h"
#include "tregkey.h"
#include "resource.h"
#include "wins.h"
#include <clusapi.h>
#include "..\tfscore\cluster.h"
const TCHAR g_szPipeName[] = _T("\\pipe\\WinsPipe");
const TCHAR g_szDefaultHelpTopic[] = _T("\\help\\winsconcepts.chm::/sag_WINStopnode.htm");
/*---------------------------------------------------------------------------
SendTrigger()
Sends a pull or push replication trigger to a given wins server
---------------------------------------------------------------------------*/
DWORD
SendTrigger
(
handle_t hWins,
LONG ipTarget,
BOOL fPush,
BOOL fPropagate
)
{
DWORD dwStatus;
WINSINTF_ADD_T WinsAdd;
WinsAdd.Len = 4;
WinsAdd.Type = 0;
WinsAdd.IPAdd = ipTarget;
WINSINTF_TRIG_TYPE_E TrigType;
TrigType = fPush ? (fPropagate ? WINSINTF_E_PUSH_PROP : WINSINTF_E_PUSH) : WINSINTF_E_PULL;
#ifdef WINS_CLIENT_APIS
dwStatus = ::WinsTrigger(hWins,
&WinsAdd,
TrigType);
#else
dwStatus = ::WinsTrigger(&WinsAdd,
TrigType);
#endif WINS_CLIENT_APIS
return dwStatus;
}
/*---------------------------------------------------------------------------
ControlWINSService(LPCTSTR pszName, BOOL bStop)
Stops ot starts the WINS service on the local machine
---------------------------------------------------------------------------*/
DWORD ControlWINSService(LPCTSTR pszName, BOOL bStop)
{
DWORD dwState = bStop ? SERVICE_STOPPED : SERVICE_RUNNING;
DWORD dwPending = bStop ? SERVICE_STOP_PENDING : SERVICE_START_PENDING;
DWORD err = ERROR_SUCCESS;
int i;
SERVICE_STATUS ss;
DWORD dwControl;
BOOL fSuccess;
SC_HANDLE hService = NULL;
SC_HANDLE hScManager = NULL;
// oepmnt he service control manager
hScManager = ::OpenSCManager(pszName, NULL, SC_MANAGER_ALL_ACCESS);
if (hScManager == NULL)
{
err = ::GetLastError();
Trace1("ControlWINSService - OpenScManager failed! %d\n", err);
goto Error;
}
// get the handle to the WINS service
hService = OpenService(hScManager, _T("WINS"), SERVICE_ALL_ACCESS);
if (hService == NULL)
{
err = ::GetLastError();
Trace1("ControlWINSService - OpenService failed! %d\n", err);
goto Error;
}
// if stop requested
if (bStop)
{
dwControl = SERVICE_CONTROL_STOP;
fSuccess = ::ControlService(hService, dwControl, &ss);
if (!fSuccess)
{
err = ::GetLastError();
Trace1("ControlWINSService - ControlService failed! %d\n", err);
goto Error;
}
}
// otherwise start the service
else
{
fSuccess = ::StartService(hService, 0, NULL);
if (!fSuccess)
{
err = ::GetLastError();
Trace1("ControlWINSService - StartService failed! %d\n", err);
goto Error;
}
}
#define LOOP_TIME 5000
#define NUM_LOOPS 600
// wait for the service to start/stop.
for (i = 0; i < NUM_LOOPS; i++)
{
::QueryServiceStatus(hService, &ss);
// check to see if we are done
if (ss.dwCurrentState == dwState)
{
int time = LOOP_TIME * i;
Trace1("ControlWINSService - service stopped/started in approx %d ms!\n", time);
break;
}
// now see if something bad happened
if (ss.dwCurrentState != dwPending)
{
int time = LOOP_TIME * i;
Trace1("ControlWINSService - service stop/start failed in approx %d ms!\n", time);
break;
}
Sleep(LOOP_TIME);
}
if (i == NUM_LOOPS)
Trace0("ControlWINSService - service did NOT stop/start in wait period!\n");
if (ss.dwCurrentState != dwState)
err = ERROR_SERVICE_REQUEST_TIMEOUT;
Error:
// close the respective handles
if (hService)
::CloseServiceHandle(hService);
if (hScManager)
::CloseServiceHandle(hScManager);
return err;
}
/*---------------------------------------------------------------------------
GetNameIP( const CString &strDisplay,
CString &strName,
CString &strIP)
Returns the Server name and the IP Address string with the
group name
---------------------------------------------------------------------------*/
void
GetNameIP
(
const CString &strDisplay,
CString &strName,
CString &strIP
)
{
CString strTemp = strDisplay;
// find '['
int nPos = strDisplay.Find(_T("["));
// left of the positioncontains the name and right of it has the IP address
// 1 to take care of the space before '['
strName = strDisplay.Left(nPos-1);
strIP = strDisplay.Right(strDisplay.GetLength() - nPos);
// take out '[' and ']' in strIP
int npos1 = strIP.Find(_T("["));
int npos2 = strIP.Find(_T("]"));
strIP = strIP.Mid(npos1+1, npos2-npos1-1);
return;
}
/*---------------------------------------------------------------------------
WideToMBCS()
converts WCS to MBCS string
NOTE: the caller of this function must make sure that szOut is big
enough to hold any possible string in strIn.
---------------------------------------------------------------------------*/
DWORD
WideToMBCS(CString & strIn, LPSTR szOut, UINT uCodePage, DWORD dwFlags, BOOL * pfDefaultUsed)
{
DWORD dwErr = ERROR_SUCCESS;
BOOL fDefaultCharUsed = FALSE;
int nNumBytes = ::WideCharToMultiByte(uCodePage,
dwFlags,
strIn,
-1,
szOut,
0,
NULL,
&fDefaultCharUsed);
dwErr = ::WideCharToMultiByte(uCodePage,
dwFlags,
strIn,
-1,
szOut,
nNumBytes,
NULL,
&fDefaultCharUsed);
szOut[nNumBytes] = '\0';
if (pfDefaultUsed)
*pfDefaultUsed = fDefaultCharUsed;
return dwErr;
}
/*---------------------------------------------------------------------------
MBCSToWide ()
converts MBCS to Wide string
---------------------------------------------------------------------------*/
DWORD
MBCSToWide(LPSTR szIn, CString & strOut, UINT uCodePage, DWORD dwFlags)
{
DWORD dwErr = ERROR_SUCCESS;
LPTSTR pBuf = strOut.GetBuffer(MAX_PATH * 2);
ZeroMemory(pBuf, MAX_PATH * 2);
dwErr = ::MultiByteToWideChar(uCodePage,
dwFlags,
szIn,
-1,
pBuf,
MAX_PATH * 2);
strOut.ReleaseBuffer();
return dwErr;
}
LONG
GetSystemMessageA
(
UINT nId,
CHAR * chBuffer,
int cbBuffSize
)
{
CHAR * pszText = NULL ;
HINSTANCE hdll = NULL ;
DWORD flags = FORMAT_MESSAGE_IGNORE_INSERTS
| FORMAT_MESSAGE_MAX_WIDTH_MASK;
//
// Interpret the error. Need to special case
// the lmerr & ntstatus ranges, as well as
// WINS server error messages.
//
if( nId >= NERR_BASE && nId <= MAX_NERR )
{
hdll = LoadLibrary( _T("netmsg.dll") );
}
else
if( nId >= 0x40000000L )
{
hdll = LoadLibrary( _T("ntdll.dll") );
}
if( hdll == NULL )
{
flags |= FORMAT_MESSAGE_FROM_SYSTEM;
}
else
{
flags |= FORMAT_MESSAGE_FROM_HMODULE;
}
//
// Let FormatMessage do the dirty work.
//
DWORD dwResult = ::FormatMessageA( flags,
(LPVOID) hdll,
nId,
0,
chBuffer,
cbBuffSize,
NULL ) ;
if( hdll != NULL )
{
LONG err = GetLastError();
FreeLibrary( hdll );
if ( dwResult == 0 )
{
::SetLastError( err );
}
}
return dwResult ? ERROR_SUCCESS : ::GetLastError() ;
}
LONG
GetSystemMessage
(
UINT nId,
TCHAR * chBuffer,
int cbBuffSize
)
{
TCHAR * pszText = NULL ;
HINSTANCE hdll = NULL ;
DWORD flags = FORMAT_MESSAGE_IGNORE_INSERTS
| FORMAT_MESSAGE_MAX_WIDTH_MASK;
//
// Interpret the error. Need to special case
// the lmerr & ntstatus ranges, as well as
// WINS server error messages.
//
if( nId >= NERR_BASE && nId <= MAX_NERR )
{
hdll = LoadLibrary( _T("netmsg.dll") );
}
else
if( nId >= 0x40000000L )
{
hdll = LoadLibrary( _T("ntdll.dll") );
}
if( hdll == NULL )
{
flags |= FORMAT_MESSAGE_FROM_SYSTEM;
}
else
{
flags |= FORMAT_MESSAGE_FROM_HMODULE;
}
//
// Let FormatMessage do the dirty work.
//
DWORD dwResult = ::FormatMessage( flags,
(LPVOID) hdll,
nId,
0,
chBuffer,
cbBuffSize,
NULL ) ;
if( hdll != NULL )
{
LONG err = GetLastError();
FreeLibrary( hdll );
if ( dwResult == 0 )
{
::SetLastError( err );
}
}
return dwResult ? ERROR_SUCCESS : ::GetLastError() ;
}
/*!--------------------------------------------------------------------------
LoadMessage
Loads the error message from the correct DLL.
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
LoadMessage
(
UINT nIdPrompt,
TCHAR * chMsg,
int nMsgSize
)
{
BOOL bOk;
//
// Substitute a friendly message for "RPC server not
// available" and "No more endpoints available from
// the endpoint mapper".
//
if (nIdPrompt == EPT_S_NOT_REGISTERED ||
nIdPrompt == RPC_S_SERVER_UNAVAILABLE)
{
nIdPrompt = IDS_ERR_WINS_DOWN;
}
//
// If it's a socket error or our error, the text is in our resource fork.
// Otherwise, use FormatMessage() and the appropriate DLL.
//
if ( (nIdPrompt >= IDS_ERR_BASE && nIdPrompt < IDS_MSG_LAST) )
{
//
// It's in our resource fork
//
bOk = ::LoadString( AfxGetInstanceHandle(), nIdPrompt, chMsg, nMsgSize / sizeof(TCHAR) ) != 0 ;
}
else
{
//
// It's in the system somewhere.
//
bOk = GetSystemMessage( nIdPrompt, chMsg, nMsgSize ) == 0 ;
}
if (bOk && nIdPrompt == ERROR_ACCESS_DENIED)
{
// tack on our extra help to explain different acess levels
CString strAccessDeniedHelp;
strAccessDeniedHelp.LoadString(IDS_ACCESS_DENIED_HELP);
lstrcat(chMsg, _T("\n\n"));
lstrcat(chMsg, strAccessDeniedHelp);
}
//
// If the error message did not compute, replace it.
//
if ( ! bOk )
{
TCHAR chBuff [STRING_LENGTH_MAX] ;
static const TCHAR * pszReplacement = _T("System Error: %ld");
const TCHAR * pszMsg = pszReplacement ;
//
// Try to load the generic (translatable) error message text
//
if ( ::LoadString( AfxGetInstanceHandle(), IDS_ERR_MESSAGE_GENERIC,
chBuff, STRING_LENGTH_MAX ) != 0 )
{
pszMsg = chBuff ;
}
::wsprintf( chMsg, pszMsg, nIdPrompt ) ;
}
return bOk;
}
/*!--------------------------------------------------------------------------
WinsMessageBox
Puts up a message box with the corresponding error text.
Author: EricDav
---------------------------------------------------------------------------*/
int WinsMessageBox(UINT nIdPrompt,
UINT nType ,
const TCHAR * pszSuffixString,
UINT nHelpContext)
{
TCHAR chMesg [4000] ;
BOOL bOk ;
CThemeContextActivator themeActivator;
bOk = LoadMessage(nIdPrompt, chMesg, sizeof(chMesg)/sizeof(TCHAR));
if ( pszSuffixString )
{
::lstrcat( chMesg, _T(" ") ) ;
::lstrcat( chMesg, pszSuffixString ) ;
}
return ::AfxMessageBox( chMesg, nType, nHelpContext ) ;
}
/*!--------------------------------------------------------------------------
WinsMessageBoxEx
Puts up a message box with the corresponding error text.
Author: EricDav
---------------------------------------------------------------------------*/
int
WinsMessageBoxEx
(
UINT nIdPrompt,
LPCTSTR pszPrefixMessage,
UINT nType,
UINT nHelpContext
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TCHAR chMesg[4000];
CString strMessage;
BOOL bOk;
CThemeContextActivator themeActivator;
bOk = LoadMessage(nIdPrompt, chMesg, sizeof(chMesg)/sizeof(TCHAR));
if ( pszPrefixMessage )
{
strMessage = pszPrefixMessage;
strMessage += _T("\n");
strMessage += _T("\n");
strMessage += chMesg;
}
else
{
strMessage = chMesg;
}
return AfxMessageBox(strMessage, nType, nHelpContext);
}
// class NameTypeMapping handlers
/*!--------------------------------------------------------------------------
MapDWORDToCString
Generic mapping of a DWORD to a CString.
dwNameType is the 16th byte of the name.
dwWinsType is Unique, multihomed, group, etc...
Author: KennT
---------------------------------------------------------------------------*/
void MapDWORDToCString(DWORD dwNameType, DWORD dwWinsType, const CStringMapArray * pMap, CString & strName)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CStringMapEntry mapEntry;
for (int i = 0; i < pMap->GetSize(); i++)
{
mapEntry = pMap->GetAt(i);
// break out if this is the correct type and the wins type
// matches or is a don't care
if ( (mapEntry.dwNameType == dwNameType) &&
( (mapEntry.dwWinsType == -1) ||
(mapEntry.dwWinsType == dwWinsType) ) )
{
break;
}
mapEntry.dwNameType = 0xFFFFFFFF;
}
if (mapEntry.dwNameType == 0xFFFFFFFF)
{
MapDWORDToCString(NAME_TYPE_OTHER, dwWinsType, pMap, strName);
}
else
{
if (mapEntry.st.IsEmpty())
Verify(pMap->GetAt(i).st.LoadString(mapEntry.ulStringId));
strName = pMap->GetAt(i).st;
}
}
// this structure allows us to map name types to strings. The secondary
// check is based on the wins defined record type. In order for this to work
// correctly, place any names that need to be defined with the wins type before
// the entry with the wins type set to -1.
static const UINT s_NameTypeMappingDefault[NUM_DEFAULT_NAME_TYPES][3] =
{
{ NAME_TYPE_WORKSTATION, WINSINTF_E_NORM_GROUP, IDS_NAMETYPE_MAP_WORKGROUP },
{ NAME_TYPE_WORKSTATION, -1, IDS_NAMETYPE_MAP_WORKSTATION },
{ NAME_TYPE_DC, -1, IDS_NAMETYPE_MAP_DC },
{ NAME_TYPE_FILE_SERVER, WINSINTF_E_SPEC_GROUP, IDS_NAMETYPE_MAP_SPECIAL_INTERNET_GROUP },
{ NAME_TYPE_FILE_SERVER, -1, IDS_NAMETYPE_MAP_FILE_SERVER },
{ NAME_TYPE_DMB , -1, IDS_NAMETYPE_MAP_DMB },
{ NAME_TYPE_OTHER, -1, IDS_NAMETYPE_MAP_OTHER },
{ NAME_TYPE_NETDDE, -1, IDS_NAMETYPE_MAP_NETDDE },
{ NAME_TYPE_MESSENGER, -1, IDS_NAMETYPE_MAP_MESSENGER },
{ NAME_TYPE_RAS_SERVER, -1, IDS_NAMETYPE_MAP_RAS_SERVER },
{ NAME_TYPE_NORM_GRP_NAME, -1, IDS_NAMETYPE_MAP_NORMAL_GROUP_NAME },
{ NAME_TYPE_WORK_NW_MON_AGENT, -1, IDS_NAMETYPE_MAP_NW_MON_AGENT },
{ NAME_TYPE_WORK_NW_MON_NAME, -1, IDS_NAMETYPE_MAP_NMN},
};
const NameTypeMapping::REGKEYNAME NameTypeMapping::c_szNameTypeMapKey = _T("SYSTEM\\CurrentControlSet\\Services\\wins\\NameTypeMap");
const NameTypeMapping::REGKEYNAME NameTypeMapping::c_szDefault= _T("(Default)");
NameTypeMapping ::NameTypeMapping()
{
}
NameTypeMapping ::~NameTypeMapping()
{
Unload();
}
void
NameTypeMapping ::SetMachineName(LPCTSTR pszMachineName)
{
m_strMachineName = pszMachineName;
}
HRESULT NameTypeMapping::Load()
{
HRESULT hr = hrOK;
RegKey regkey;
RegKey regkeyMachine;
HKEY hkeyMachine = HKEY_LOCAL_MACHINE;
RegKey::CREGKEY_KEY_INFO regkeyInfo;
RegKeyIterator regkeyIter;
UINT i;
WORD langID;
RegKey regkeyProto;
DWORD dwErr;
CStringMapEntry mapEntry;
::ZeroMemory(&regkeyInfo, sizeof(regkeyInfo));
// Look for the registry key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.Open(hkeyMachine, c_szNameTypeMapKey, KEY_READ, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// Get the count of items
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.QueryKeyInfo(&regkeyInfo) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// Alloc the array for the count of items + default items
Unload();
// Read in the registry data and add it to the internal array
//
// enumerate the keys
//
if (FHrSucceeded(hr))
hr = regkeyIter.Init(&regkey);
if (FHrSucceeded(hr))
{
HRESULT hrIter;
DWORD dwProtoId;
CString stKey;
CString stLang;
// Now that we have this key, look for the language id
langID = GetUserDefaultLangID();
stLang.Format(_T("%04x"), (DWORD)langID);
for (hrIter = regkeyIter.Next(&stKey, NULL); hrIter == hrOK; hrIter = regkeyIter.Next(&stKey, NULL))
{
CString st;
// Given the name of the key, that is a hex value (the protocol id)
// Convert that into a DWORD
dwProtoId = _tcstoul((LPCTSTR) stKey, NULL, 16);
// Open this key
regkeyProto.Close();
dwErr = regkeyProto.Open(regkey, stKey);
if (!FHrSucceeded(HRESULT_FROM_WIN32(dwErr)))
continue;
// Ok, get the name value
dwErr = regkeyProto.QueryValue(stLang, st);
if (!FHrSucceeded(HRESULT_FROM_WIN32(dwErr)))
{
// Look for the key with the name of default
dwErr = regkeyProto.QueryValue(c_szDefault, st);
}
if (FHrSucceeded(HRESULT_FROM_WIN32(dwErr)))
{
// Ok, add this value to the list
mapEntry.dwNameType = dwProtoId;
mapEntry.st = st;
mapEntry.ulStringId = 0;
Add(mapEntry);
}
}
}
// Read in the default item data and add it to the array
for (i = 0; i < DimensionOf(s_NameTypeMappingDefault); i++)
{
mapEntry.dwNameType = s_NameTypeMappingDefault[i][0];
mapEntry.dwWinsType = s_NameTypeMappingDefault[i][1];
mapEntry.st.LoadString(s_NameTypeMappingDefault[i][2]);
mapEntry.ulStringId = 0;
Add(mapEntry);
}
return hrOK;
}
void NameTypeMapping::Unload()
{
RemoveAll();
}
void NameTypeMapping::TypeToCString(DWORD dwProtocolId, DWORD dwRecordType, CString & strName)
{
MapDWORDToCString(dwProtocolId, dwRecordType, this, strName);
}
// add in the new id/name
HRESULT NameTypeMapping::AddEntry(DWORD dwProtocolId, LPCTSTR pstrName)
{
HRESULT hr = hrOK;
RegKey regkey;
RegKey regkeyID;
HKEY hkeyMachine = HKEY_LOCAL_MACHINE;
WORD langID;
CStringMapEntry mapEntry;
CString stID, stLang, stNew;
// Look for the registry key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.Create(hkeyMachine, c_szNameTypeMapKey, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,NULL, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// build our new ID string
stID.Format(_T("%04x"), (DWORD) dwProtocolId);
// Now that we have this key, look for the language id
langID = GetUserDefaultLangID();
stLang.Format(_T("%04x"), (DWORD)langID);
stNew = c_szNameTypeMapKey + _T("\\") + stID;
// create the ID key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkeyID.Create(hkeyMachine, stNew, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,NULL, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// set the name value
if (FHrSucceeded(hr))
{
DWORD dwErr = regkeyID.SetValue(stLang, pstrName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
if (FHrSucceeded(hr))
{
// add to internal list
mapEntry.dwNameType = dwProtocolId;
mapEntry.st = pstrName;
mapEntry.ulStringId = 0;
Add(mapEntry);
}
return hr;
}
// modify the given ID's string name
HRESULT NameTypeMapping::ModifyEntry(DWORD dwProtocolId, LPCTSTR pstrName)
{
HRESULT hr = hrOK;
RegKey regkey;
RegKey regkeyID;
HKEY hkeyMachine = HKEY_LOCAL_MACHINE;
int i;
WORD langID;
CString stID, stLang, stNew;
// Look for the registry key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.Open(hkeyMachine, c_szNameTypeMapKey, KEY_READ, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// build our new ID string
stID.Format(_T("%04x"), (DWORD) dwProtocolId);
stNew = c_szNameTypeMapKey + _T("\\") + stID;
// open the correct ID key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkeyID.Open(hkeyMachine, stNew, KEY_ALL_ACCESS, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// Now that we have this key, look for the language id
langID = GetUserDefaultLangID();
stLang.Format(_T("%04x"), (DWORD)langID);
// set the new value
if (FHrSucceeded(hr))
{
DWORD dwErr = regkeyID.SetValue(stLang, pstrName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
if (FHrSucceeded(hr))
{
// modify the internal list
for (i = 0; i < GetSize(); i++)
{
if (GetAt(i).dwNameType == dwProtocolId)
{
m_pData[i].st = pstrName;
break;
}
}
}
return hr;
}
// remove the given ID's string name
HRESULT NameTypeMapping::RemoveEntry(DWORD dwProtocolId)
{
HRESULT hr = hrOK;
RegKey regkey;
HKEY hkeyMachine = HKEY_LOCAL_MACHINE;
int i;
CString stID;
// Look for the registry key
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.Open(hkeyMachine, c_szNameTypeMapKey, KEY_READ, m_strMachineName) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
// build our new ID string
stID.Format(_T("%04x"), (DWORD) dwProtocolId);
// set the new value
if (FHrSucceeded(hr))
{
DWORD dwErr = regkey.RecurseDeleteKey(stID) ;
hr = HRESULT_FROM_WIN32( dwErr );
}
if (FHrSucceeded(hr))
{
// modify the internal list
for (i = 0; i < GetSize(); i++)
{
if (GetAt(i).dwNameType == dwProtocolId)
{
RemoveAt(i);
break;
}
}
}
return hr;
}
BOOL
NameTypeMapping::EntryExists(DWORD dwProtocolId)
{
BOOL fExists = FALSE;
for (int i = 0; i < GetSize(); i++)
{
if (GetAt(i).dwNameType == dwProtocolId)
{
fExists = TRUE;
break;
}
}
return fExists;
}
/*---------------------------------------------------------------------------
CleanString(CString& str)
Strip leading and trailing spaces from the string.
---------------------------------------------------------------------------*/
CString&
CleanString(
CString& str
)
{
if (str.IsEmpty())
{
return str ;
}
int n = 0;
while ((n < str.GetLength()) && (str[n] == ' '))
{
++n;
}
if (n)
{
str = str.Mid(n);
}
n = str.GetLength();
while (n && (str[--n] == ' '))
{
str.ReleaseBuffer(n);
}
return str;
}
/*---------------------------------------------------------------------------
IsValidNetBIOSName
Determine if the given netbios is valid, and pre-pend
a double backslash if not already present (and the address
is otherwise valid).
---------------------------------------------------------------------------*/
BOOL
IsValidNetBIOSName(
CString & strAddress,
BOOL fLanmanCompatible,
BOOL fWackwack // expand slashes if not present
)
{
TCHAR szWacks[] = _T("\\\\");
if (strAddress.IsEmpty())
{
return FALSE;
}
if (strAddress[0] == _T('\\'))
{
if (strAddress.GetLength() < 3)
{
return FALSE;
}
if (strAddress[1] != _T('\\'))
{
// One slash only? Not valid
return FALSE;
}
}
else
{
if (fWackwack)
{
// Add the backslashes
strAddress = szWacks + strAddress;
}
}
int nMaxAllowedLength = fLanmanCompatible
? LM_NAME_MAX_LENGTH
: NB_NAME_MAX_LENGTH;
if (fLanmanCompatible)
{
strAddress.MakeUpper();
}
return strAddress.GetLength() <= nMaxAllowedLength + 2;
}
/*---------------------------------------------------------------------------
IsValidDomain
Determine if the given domain name address is valid, and clean
it up, if necessary
---------------------------------------------------------------------------*/
BOOL
IsValidDomain(CString & strDomain)
{
/* int nLen;
if ((nLen = strDomain.GetLength()) != 0)
{
if (nLen < DOMAINNAME_LENGTH) // 255
{
int i;
int istr = 0;
TCHAR ch;
BOOL fLet_Dig = FALSE;
BOOL fDot = FALSE;
int cHostname = 0;
for (i = 0; i < nLen; i++)
{
// check each character
ch = strDomain[i];
BOOL fAlNum = iswalpha(ch) || iswdigit(ch);
if (((i == 0) && !fAlNum) ||
// first letter must be a digit or a letter
(fDot && !fAlNum) ||
// first letter after dot must be a digit or a letter
((i == (nLen - 1)) && !fAlNum) ||
// last letter must be a letter or a digit
(!fAlNum && ( ch != _T('-') && ( ch != _T('.') && ( ch != _T('_'))))) ||
// must be letter, digit, - or "."
(( ch == _T('.')) && ( !fLet_Dig )))
// must be letter or digit before '.'
{
return FALSE;
}
fLet_Dig = fAlNum;
fDot = (ch == _T('.'));
cHostname++;
if ( cHostname > HOSTNAME_LENGTH )
{
return FALSE;
}
if ( fDot )
{
cHostname = 0;
}
}
}
}
*/
return TRUE;
}
/*---------------------------------------------------------------------------
IsValidIpAddress
Determine if the given IP address is valid, and clean
it up, if necessary
---------------------------------------------------------------------------*/
BOOL
IsValidIpAddress(CString & strAddress)
{
if (strAddress.IsEmpty())
{
return FALSE;
}
CIpAddress ia(strAddress);
BOOL fValid = ia.IsValid();
if (fValid)
{
// Fill out the IP address string for clarity
strAddress = ia;
return TRUE;
}
return FALSE;
}
/*---------------------------------------------------------------------------
IsValidAddress
Determine if the given address is a valid NetBIOS or
TCP/IP address, judging by the name only. Note that
validation may clean up the given string
NetBIOS names not beginning with "\\" will have those characters
pre-pended, and otherwise valid IP Addresses are filled out to
4 octets.
Leading and trailing spaces are removed from the string.
--------------------------------------------------------------------------*/
BOOL
IsValidAddress(
CString& strAddress,
BOOL * fIpAddress,
BOOL fLanmanCompatible,
BOOL fWackwack // expand netbios slashes
)
{
int i;
// Remove leading and trailing spaces
CleanString(strAddress);
if (strAddress.IsEmpty()) {
*fIpAddress = FALSE;
return FALSE;
}
if (strAddress[0] == _T('\\')) {
*fIpAddress = FALSE;
return IsValidNetBIOSName(strAddress, fLanmanCompatible, fWackwack);
}
if (IsValidIpAddress(strAddress))
{
*fIpAddress = TRUE;
return TRUE;
}
else
{
*fIpAddress = FALSE;
}
if (IsValidDomain (strAddress)) {
return TRUE;
}
// last chance, maybe its a NetBIOS name w/o wackwack
return IsValidNetBIOSName(strAddress, fLanmanCompatible, fWackwack);
}
/*---------------------------------------------------------------------------
VerifyWinsServer(CString& strServer,CString& strIP)
Called if the server is not coonected yet, gets the name and
IP address od the server
Author:v-shubk
---------------------------------------------------------------------------*/
/*
DWORD
VerifyWinsServer(CString &strAddress, CString &strServerName, DWORD & dwIP)
{
CString strNameIP = strAddress;
BOOL fIp;
DWORD err = ERROR_SUCCESS;
if (IsValidAddress(strNameIP, &fIp, TRUE, TRUE))
{
CWinsServerObj ws(NULL,"", TRUE, TRUE);
if (fIp)
{
// IP address specified
ws = CWinsServerObj(CIpAddress(strNameIP), "", TRUE, TRUE);
}
else
{
// machine name specified
ws = CWinsServerObj(CIpAddress(), strNameIP, TRUE, TRUE);
}
WINSINTF_BIND_DATA_T wbdBindData;
handle_t hBinding = NULL;
WINSINTF_ADD_T waWinsAddress;
char szNetBIOSName[256] = {0};
do
{
// First attempt to bind to the new address
wbdBindData.fTcpIp = ws.GetNetBIOSName().IsEmpty();
CString strTempAddress;
if (wbdBindData.fTcpIp)
{
strTempAddress = ((CString)ws.GetIpAddress());
}
else
{
//strTempAddress = _T("\\\\") + ws.GetNetBIOSName();
CString tmp;
tmp = ws.GetNetBIOSName();
if ( (tmp[0] == _T('\\')) && (tmp[1] == _T('\\')) )
strTempAddress = ws.GetNetBIOSName();
else
strTempAddress = _T("\\\\") + ws.GetNetBIOSName();
}
wbdBindData.pPipeName = wbdBindData.fTcpIp ? NULL : (LPSTR) g_szPipeName;
wbdBindData.pServerAdd = (LPSTR) (LPCTSTR) strTempAddress;
if ((hBinding = ::WinsBind(&wbdBindData)) == NULL)
{
err = ::GetLastError();
break;
}
#ifdef WINS_CLIENT_APIS
err = ::WinsGetNameAndAdd(hBinding,
&waWinsAddress,
(LPBYTE) szNetBIOSName);
#else
err = ::WinsGetNameAndAdd(&waWinsAddress,
(LPBYTE) szNetBIOSName);
#endif WINS_CLIENT_APIS
}
while (FALSE);
if (err == ERROR_SUCCESS)
{
// Always use the IP address used for connection
// if we went over tcpip (not the address returned
// by the WINS service.
if (wbdBindData.fTcpIp)
{
CIpNamePair ip(ws.GetIpAddress(), szNetBIOSName);
ws = ip;
}
else
{
CIpNamePair ip(waWinsAddress.IPAdd, szNetBIOSName);
ws = ip;
}
// convert the dbcs netbios name to wide char
WCHAR szTempIP[20] = {0};
int nNumBytes = MultiByteToWideChar(CP_ACP,
0,
szNetBIOSName,
-1,
szTempIP,
20);
// now fill in the name for return
strServerName = szTempIP;
// fill in the IP
dwIP = (LONG) ws.QueryIpAddress();
}
if (hBinding)
{
// call winsunbind here, No more WINS apis called atfer this
WinsUnbind(&wbdBindData, hBinding);
hBinding = NULL;
}
}
return err;
}
*/
/*---------------------------------------------------------------------------
VerifyWinsServer(CString& strServer,CString& strIP)
Called if the server is not coonected yet, gets the name and
IP address od the server
Author: ericdav
---------------------------------------------------------------------------*/
DWORD
VerifyWinsServer(CString &strAddress, CString &strServerName, DWORD & dwIP)
{
CString strNameIP = strAddress;
BOOL fIp;
DWORD err = ERROR_SUCCESS;
if (IsValidAddress(strNameIP, &fIp, TRUE, TRUE))
{
CWinsServerObj ws(NULL, "", TRUE, TRUE);
if (fIp)
{
BOOL bIsCluster = ::FIsComputerInRunningCluster(strNameIP);
// IP address specified
ws = CWinsServerObj(CIpAddress(strNameIP), "", TRUE, TRUE);
// if the ip address given to us is a cluster address..
if (bIsCluster)
{
err = GetClusterInfo(
strNameIP,
strServerName,
&dwIP);
if (err == ERROR_SUCCESS)
{
DWORD dwCheckIP;
err = GetHostAddress(strServerName, &dwCheckIP);
if (dwCheckIP != dwIP)
{
bIsCluster = FALSE;
}
}
}
// this is not a cluster address
if (!bIsCluster)
{
err = GetHostName((LONG) ws.GetIpAddress(), strServerName);
if (err == ERROR_SUCCESS)
{
if (strServerName.IsEmpty())
{
err = DNS_ERROR_NAME_DOES_NOT_EXIST;
}
else
{
// just want the host name
int nDot = strServerName.Find('.');
if (nDot != -1)
{
strServerName = strServerName.Left(nDot);
}
}
dwIP = (LONG) ws.GetIpAddress();
}
}
}
else
{
// machine name specified
ws = CWinsServerObj(CIpAddress(), strNameIP, TRUE, TRUE);
err = GetHostAddress(strNameIP, &dwIP);
if (err == ERROR_SUCCESS)
{
// just want the host name
int nDot = strNameIP.Find('.');
if (nDot != -1)
{
strServerName = strNameIP.Left(nDot);
}
else
{
strServerName = strNameIP;
}
}
}
}
return err;
}
void MakeIPAddress(DWORD dwIP, CString & strIP)
{
CString strTemp;
DWORD dwFirst = GETIP_FIRST(dwIP);
DWORD dwSecond = GETIP_SECOND(dwIP);
DWORD dwThird = GETIP_THIRD(dwIP);
DWORD dwLast = GETIP_FOURTH(dwIP);
strIP.Empty();
// wrap it into CString object
TCHAR szStr[20] = {0};
_itot(dwFirst, szStr, 10);
strTemp = szStr;
strTemp += _T(".");
_itot(dwSecond, szStr, 10);
strTemp += szStr;
strTemp += _T(".");
_itot(dwThird, szStr, 10);
strTemp += szStr;
strTemp += _T(".");
_itot(dwLast, szStr, 10);
strTemp += szStr;
strIP = strTemp;
}
DWORD
GetHostName
(
DWORD dwIpAddr,
CString & strHostName
)
{
CString strName;
//
// Call the Winsock API to get host name information.
//
strHostName.Empty();
u_long ulAddrInNetOrder = ::htonl( (u_long) dwIpAddr ) ;
HOSTENT * pHostInfo = ::gethostbyaddr( (CHAR *) & ulAddrInNetOrder,
sizeof ulAddrInNetOrder,
PF_INET ) ;
if ( pHostInfo == NULL )
{
return ::WSAGetLastError();
}
// copy the name
MBCSToWide(pHostInfo->h_name, strName);
strName.MakeUpper();
int nDot = strName.Find(_T("."));
if (nDot != -1)
strHostName = strName.Left(nDot);
else
strHostName = strName;
return NOERROR;
}
/*---------------------------------------------------------------------------
GetHostAddress
Description
Author: EricDav
---------------------------------------------------------------------------*/
DWORD
GetHostAddress
(
LPCTSTR pszHostName,
DWORD * pdwIp
)
{
DWORD err = ERROR_SUCCESS;
CHAR szString [ 2 * (MAX_PATH + 1)] = {0}; // large enough for a MAX_PATH MBCS encoding
CString strTemp(pszHostName);
WideToMBCS(strTemp, szString);
HOSTENT * pHostent = ::gethostbyname( szString ) ;
if ( pHostent )
{
*pdwIp = ::ntohl( *((u_long *) pHostent->h_addr_list[0]) ) ;
}
else
{
err = ::WSAGetLastError() ;
}
return err ;
}
//
// This function makes the appropriate call to either WinsStatus or WinsStatusNew
//
CWinsResults::CWinsResults()
{
NoOfOwners = 0;
AddVersMaps.RemoveAll();
MyMaxVersNo.QuadPart = 0;
RefreshInterval = 0;
TombstoneInterval = 0;
TombstoneTimeout = 0;
VerifyInterval = 0;
WinsPriorityClass = 0;
NoOfWorkerThds = 0;
memset(&WinsStat, 0, sizeof(WinsStat));
}
CWinsResults::CWinsResults(WINSINTF_RESULTS_T * pwrResults)
{
Set(pwrResults);
}
CWinsResults::CWinsResults(WINSINTF_RESULTS_NEW_T * pwrResults)
{
Set(pwrResults);
}
DWORD
CWinsResults::Update(handle_t hBinding)
{
DWORD err;
//
// First try the new API which does not
// not have the 25 partner limitation. If
// this fails with RPC_S_PROCNUM_OUT_OF_RANGE,
// we know the server is a down-level server,
// and we need to call the old method.
//
err = GetNewConfig(hBinding);
if (err == RPC_S_PROCNUM_OUT_OF_RANGE)
{
//
// Try old API
//
err = GetConfig(hBinding);
}
return err;
}
DWORD
CWinsResults::GetNewConfig(handle_t hBinding)
{
WINSINTF_RESULTS_NEW_T wrResults;
wrResults.WinsStat.NoOfPnrs = 0;
wrResults.WinsStat.pRplPnrs = NULL;
wrResults.NoOfWorkerThds = 1;
wrResults.pAddVersMaps = NULL;
#ifdef WINS_CLIENT_APIS
DWORD dwStatus = ::WinsStatusNew(hBinding, WINSINTF_E_CONFIG_ALL_MAPS, &wrResults);
#else
DWORD dwStatus = ::WinsStatusNew(WINSINTF_E_CONFIG_ALL_MAPS, &wrResults);
#endif WINS_CLIENT_APIS
if (dwStatus == ERROR_SUCCESS)
{
Set(&wrResults);
}
else
{
Clear();
}
return dwStatus;
}
DWORD
CWinsResults::GetConfig(handle_t hBinding)
{
WINSINTF_RESULTS_T wrResults;
wrResults.WinsStat.NoOfPnrs = 0;
wrResults.WinsStat.pRplPnrs = NULL;
wrResults.NoOfWorkerThds = 1;
#ifdef WINS_CLIENT_APIS
DWORD dwStatus = ::WinsStatus(hBinding, WINSINTF_E_CONFIG_ALL_MAPS, &wrResults);
#else
DWORD dwStatus = ::WinsStatus(WINSINTF_E_CONFIG_ALL_MAPS, &wrResults);
#endif WINS_CLIENT_APIS
if (dwStatus == ERROR_SUCCESS)
{
Set(&wrResults);
}
else
{
Clear();
}
return dwStatus;
}
void
CWinsResults::Clear()
{
AddVersMaps.RemoveAll();
NoOfOwners = 0;
MyMaxVersNo.QuadPart = 0;
RefreshInterval = 0;
TombstoneInterval = 0;
TombstoneTimeout = 0;
VerifyInterval = 0;
WinsPriorityClass = 0;
NoOfWorkerThds = 0;
memset(&WinsStat, 0, sizeof(WinsStat));
}
void
CWinsResults::Set(WINSINTF_RESULTS_NEW_T * pwrResults)
{
if (pwrResults)
{
NoOfOwners = pwrResults->NoOfOwners;
AddVersMaps.RemoveAll();
for (UINT i = 0; i < NoOfOwners; i++)
{
AddVersMaps.Add(pwrResults->pAddVersMaps[i]);
}
MyMaxVersNo.QuadPart = pwrResults->MyMaxVersNo.QuadPart;
RefreshInterval = pwrResults->RefreshInterval;
TombstoneInterval = pwrResults->TombstoneInterval;
TombstoneTimeout = pwrResults->TombstoneTimeout;
VerifyInterval = pwrResults->VerifyInterval;
WinsPriorityClass = pwrResults->WinsPriorityClass;
NoOfWorkerThds = pwrResults->NoOfWorkerThds;
WinsStat = pwrResults->WinsStat;
}
}
void
CWinsResults::Set(WINSINTF_RESULTS_T * pwrResults)
{
if (pwrResults == NULL)
{
Clear();
}
else
{
NoOfOwners = pwrResults->NoOfOwners;
AddVersMaps.RemoveAll();
for (UINT i = 0; i < NoOfOwners; i++)
{
AddVersMaps.Add(pwrResults->AddVersMaps[i]);
}
MyMaxVersNo.QuadPart = pwrResults->MyMaxVersNo.QuadPart;
RefreshInterval = pwrResults->RefreshInterval;
TombstoneInterval = pwrResults->TombstoneInterval;
TombstoneTimeout = pwrResults->TombstoneTimeout;
VerifyInterval = pwrResults->VerifyInterval;
WinsPriorityClass = pwrResults->WinsPriorityClass;
NoOfWorkerThds = pwrResults->NoOfWorkerThds;
WinsStat = pwrResults->WinsStat;
}
}