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.
 
 
 
 
 
 

2195 lines
64 KiB

//
// browsesrv.cpp: browse for servers list box
//
// This file is built for both UNICODE and ANSI
// and is shared between the mstsc replacement (clshell) and
// the mmc client
//
#include "stdafx.h"
#include "browsesrv.h"
//#include "atlconv.h"
#include "winsock.h"
#include "wuiids.h"
CBrowseServersCtl::CBrowseServersCtl(HINSTANCE hResInstance) : _hInst(hResInstance)
{
bIsWin95 = FALSE;
hLibrary = NULL;
#ifndef OS_WINCE
lpfnNetServerEnum = NULL;
lpfnNetApiBufferFree = NULL;
lpfnNetServerEnum2 = NULL;
lpfnNetWkStaGetInfo = NULL;
lpfnNetWkStaGetInfo_NT = NULL;
lpfnDsGetDcName = NULL;
lpfnNetEnumerateTrustedDomains = NULL;
#else
lpfnWNetOpenEnum = NULL;
lpfnWNetEnumResource = NULL;
lpfnWNetCloseEnum = NULL;
#endif
_fbrowseDNSDomain = FALSE;
_hEvent = NULL;
_hwndDialog = NULL;
_refCount = 0;
_nServerImage=0;
_nDomainImage=0;
_nDomainSelectedImage=0;
_hPrev = (HTREEITEM) TVI_FIRST;
_hPrevRootItem = NULL;
_hPrevLev2Item = NULL;
}
CBrowseServersCtl::~CBrowseServersCtl()
{
// ASSERT(0 == _refCount);
#ifdef OS_WINCE
if (hLibrary)
FreeLibrary(hLibrary);
#endif
}
//
// Ref count mechanism is used to control lifetime because up to two threads
// use this class and have different lifetimes..
//
DCINT CBrowseServersCtl::AddRef()
{
#ifdef OS_WIN32
return InterlockedIncrement( ( LPLONG )&_refCount );
#else
return InterlockedIncrement( ++_refCount );
#endif
}
DCINT CBrowseServersCtl::Release()
{
#ifdef OS_WIN32
if( InterlockedDecrement( ( LPLONG )&_refCount ) == 0 )
#else
if(0 == --_refCount)
#endif
{
delete this;
return 0;
}
return _refCount;
}
//
// Initialize the image lists
//
#define NUM_IMGLIST_ICONS 2
BOOL CBrowseServersCtl::Init(HWND hwndDlg)
{
HIMAGELIST himl; // handle to image list
HICON hIcon; // handle to icon
HWND hwndTV = NULL;
UINT uFlags = TRUE;
int cxSmIcon;
int cySmIcon;
cxSmIcon = GetSystemMetrics(SM_CXSMICON);
cySmIcon = GetSystemMetrics(SM_CYSMICON);
hwndTV = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE);
if(!hwndTV)
{
return FALSE;
}
// Create the image list.
if ((himl = ImageList_Create(cxSmIcon, cySmIcon,
TRUE, NUM_IMGLIST_ICONS, 1)) == NULL)
{
return FALSE;
}
// Add icons for the tree (computer, domain)
hIcon = (HICON)LoadImage(_hInst, MAKEINTRESOURCE(UI_IDI_SERVER), IMAGE_ICON,
cxSmIcon, cySmIcon, LR_DEFAULTCOLOR);
if (hIcon)
{
_nServerImage = ImageList_AddIcon(himl, hIcon);
DestroyIcon(hIcon);
}
hIcon = (HICON)LoadImage(_hInst, MAKEINTRESOURCE(UI_IDI_DOMAIN), IMAGE_ICON,
cxSmIcon, cySmIcon, LR_DEFAULTCOLOR);
if (hIcon)
{
_nDomainImage = ImageList_AddIcon(himl, hIcon);
DestroyIcon(hIcon);
}
// Fail if not all of the images were added.
if (ImageList_GetImageCount(himl) < NUM_IMGLIST_ICONS)
return FALSE;
// Associate the image list with the tree view control.
TreeView_SetImageList(hwndTV, himl, TVSIL_NORMAL);
return TRUE;
}
//
// Cleanup any image lists that need to be freed
//
BOOL CBrowseServersCtl::Cleanup()
{
return TRUE;
}
#ifdef OS_WIN32
/****************************************************************************/
/* Name: PopulateListBox */
/* */
/* Purpose: Fills in the owner-draw list box with the Hydra servers */
/* */
/* Returns: pointer to a domain list box item array. */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
ServerListItem*
CBrowseServersCtl::PopulateListBox(
HWND hwndDlg,
DCUINT *pDomainCount
)
{
//
// check to see we are running on win9x and call out appropriate worker
// routine.
//
#ifndef OS_WINCE
if( bIsWin95 == TRUE ) {
return( PopulateListBox95(hwndDlg, pDomainCount) );
}
#endif
return( PopulateListBoxNT(hwndDlg, pDomainCount) );
}
#ifndef OS_WINCE
/****************************************************************************/
/* Name: PopulateListBox95 */
/* */
/* Purpose: Fills in the owner-draw list box with the Hydra servers */
/* */
/* Returns: pointer to a domain list box item array. */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
ServerListItem*
CBrowseServersCtl::PopulateListBox95(
HWND hwndDlg,
DCUINT *pDomainCount
)
{
DWORD dwError;
ServerListItem *plbi = NULL;
ServerListItem *plbiAllotted = NULL;
ServerListItem *plbiReturned = NULL;
DWORD dwIndex = 0;
struct wksta_info_10 *pwki10 = NULL;
unsigned short cb;
DWORD dwDomains;
int nCount;
HWND hTree = NULL;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
//
// set return parameters to zero first.
//
*pDomainCount = 0;
//
// check to see the load library was done before calling this
// routine, if not, simply return.
//
if( lpfnNetWkStaGetInfo == NULL ) {
dwError = ERROR_INVALID_DATA;
goto Cleanup;
}
if( hwndDlg == NULL ) {
dwError = ERROR_INVALID_HANDLE;
goto Cleanup;
}
//
// get work group domain.
//
dwError = (*lpfnNetWkStaGetInfo)(NULL, 10, NULL, 0, &cb);
if( dwError != NERR_BufTooSmall ) {
goto Cleanup;
}
//
// allocated required buffer size.
//
pwki10 = (struct wksta_info_10 *)LocalAlloc(LMEM_FIXED, cb);
if( pwki10 == NULL ){
dwError = ERROR_OUTOFMEMORY;
goto Cleanup;
}
//
// query again.
//
dwError = (*lpfnNetWkStaGetInfo)(NULL, 10, (char *)pwki10, cb, &cb);
if( dwError != ERROR_SUCCESS ) {
goto Cleanup;
}
//
// check to see we are browsing a dns domain also, if so, allocated 2 list
// entries.
//
dwDomains = _fbrowseDNSDomain ? 2 : 1;
plbiAllotted = plbi =
(ServerListItem*)LocalAlloc( LMEM_FIXED, sizeof(ServerListItem) * dwDomains );
if( plbiAllotted == NULL ) {
dwError = ERROR_OUTOFMEMORY;
goto Cleanup;
}
//
// display and expand DNS domain if we need to.
//
if( _fbrowseDNSDomain ) {
_tcscpy( plbi->ContainerName, (LPTSTR)_browseDNSDomainName );
plbi->Comment[0] = _T('\0');
plbi->bContainsServers = TRUE;
plbi->bServersExpandedOnce = FALSE;
plbi->bDNSDomain = TRUE;
plbi->nServerCount = 0;
plbi->ServerItems = NULL;
AddItemToTree( hTree, plbi->ContainerName, NULL,
plbi, SRV_TREE_DOMAINLEVEL);
//
// Expand DNS Domain
//
ExpandDomain(hwndDlg, plbi->ContainerName, plbi, &dwIndex);
//
// move to the next list box entry.
//
plbi++;
}
//
// fill up the work group domain now.
//
#ifdef UNICODE
//
// convert to UNICODE.
//
nCount =
MultiByteToWideChar(
CP_ACP,
MB_COMPOSITE,
(LPSTR)pwki10->wki10_langroup,
-1,
plbi->ContainerName,
sizeof(plbi->ContainerName)/sizeof(WCHAR));
if( nCount == 0 )
{
dwError = GetLastError();
goto Cleanup;
}
#else
_tcscpy( plbi->ContainerName, pwki10->wki10_langroup );
#endif
plbi->Comment[0] = _T('\0');
plbi->bContainsServers = TRUE;
plbi->bServersExpandedOnce = FALSE;
plbi->bDNSDomain = FALSE;
plbi->nServerCount = 0;
plbi->ServerItems = NULL;
AddItemToTree( hTree, plbi->ContainerName, NULL,
plbi, SRV_TREE_DOMAINLEVEL);
//
// Expand the present Domain
//
ExpandDomain(hwndDlg, NULL, plbi, &dwIndex);
//
// we successfully populated the domain list,
// set return parameters.
//
plbiReturned = plbiAllotted;
*pDomainCount = dwDomains;
plbiAllotted = NULL;
dwError = ERROR_SUCCESS;
Cleanup:
if( plbiAllotted != NULL ) {
LocalFree(plbiAllotted);
}
if( pwki10 != NULL ) {
LocalFree(pwki10);
}
SetLastError( dwError );
return plbiReturned;
}
#endif
/****************************************************************************/
/* Name: PopulateListBoxNT */
/* */
/* Purpose: Fills in the owner-draw list box with the Hydra servers */
/* */
/* Returns: pointer to a domain list box item array. */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
ServerListItem*
CBrowseServersCtl::PopulateListBoxNT(
HWND hwndDlg,
DCUINT *pdwDomainCount
)
{
DWORD dwError;
PDCTCHAR pchTrustedDomains = NULL;
PDCTCHAR pchTDomain;
DCUINT dwDomainCount = 0;
ServerListItem *plbiAllotted = NULL;
ServerListItem *plbiReturned = NULL;
ServerListItem *plbi;
HWND hTree = NULL;
DWORD dwDlgIndex=0;
DWORD i;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
//
// set the return parameter to zero first.
//
*pdwDomainCount = 0;
if( hwndDlg == NULL ) {
dwError = ERROR_INVALID_HANDLE;
goto Cleanup;
}
//
// enumurate trusted domain names.
//
pchTrustedDomains = UIGetTrustedDomains();
if( pchTrustedDomains == NULL ) {
dwError = ERROR_CANT_ACCESS_DOMAIN_INFO;
goto Cleanup;
}
//
// count number of domains.
//
pchTDomain = pchTrustedDomains;
while( *pchTDomain != _T('\0') ) {
dwDomainCount++;
pchTDomain += (_tcslen(pchTDomain) + 1);
}
//
// check to see we need to browse the DNS domain.
//
if( _fbrowseDNSDomain ) {
dwDomainCount++;
}
//
// allocate the memory for the ServerListItem (based on the no. of domains)
//
plbiAllotted = (ServerListItem *)
LocalAlloc( LMEM_FIXED, (sizeof(ServerListItem) * dwDomainCount) );
if ( plbiAllotted == NULL ) {
dwError = ERROR_NOT_ENOUGH_MEMORY;
goto Cleanup;
}
//
// set scan variables.
//
plbi = plbiAllotted;
pchTDomain = pchTrustedDomains;
//
// display and expand DNS domain if we need to.
//
if( _fbrowseDNSDomain ) {
_tcscpy(plbi->ContainerName, (LPTSTR)_browseDNSDomainName );
plbi->Comment[0] = _T('\0');
plbi->bContainsServers = TRUE;
plbi->bServersExpandedOnce = FALSE;
plbi->bDNSDomain = TRUE;
plbi->nServerCount = 0;
plbi->ServerItems = NULL;
plbi->hTreeParentItem = NULL;
plbi->hTreeItem = AddItemToTree( hTree, plbi->ContainerName,
NULL, plbi, SRV_TREE_DOMAINLEVEL);
//
// expand the primary domain
//
ExpandDomain(hwndDlg, plbi->ContainerName, plbi, &dwDlgIndex);
//
// move to next list entry.
//
plbi++;
}
//
// first entry in the domain list is the primary domain,
// display it and expand it by default.
//
_tcscpy(plbi->ContainerName, pchTDomain);
plbi->Comment[0] = _T('\0');
plbi->bContainsServers = TRUE;
plbi->bServersExpandedOnce = FALSE;
plbi->bDNSDomain = FALSE;
plbi->nServerCount = 0;
plbi->ServerItems = NULL;
plbi->hTreeParentItem = NULL;
plbi->hTreeItem = AddItemToTree( hTree, pchTDomain, NULL, plbi,
SRV_TREE_DOMAINLEVEL);
//
// expand the primary domain
//
if(ExpandDomain(hwndDlg, NULL, plbi, &dwDlgIndex))
{
if(plbi->hTreeItem)
{
//Expand default domain
TreeView_Expand( hTree, plbi->hTreeItem, TVE_EXPAND);
}
}
//
// display other domains, don't expand them.
//
for((i = (_fbrowseDNSDomain == TRUE) ? 2 : 1); i < dwDomainCount; i++) {
//
// move to the next entry in the domain list.
//
plbi++;
pchTDomain += (_tcslen(pchTDomain) + 1);
_tcscpy(plbi->ContainerName, pchTDomain);
plbi->Comment[0] = _T('\0');
plbi->bContainsServers = TRUE;
plbi->bServersExpandedOnce = FALSE;
plbi->bDNSDomain = FALSE;
plbi->nServerCount = 0;
plbi->ServerItems = NULL;
plbi->hTreeParentItem = NULL;
plbi->hTreeItem = AddItemToTree( hTree, pchTDomain, NULL, plbi,
SRV_TREE_DOMAINLEVEL);
}
//
// we successfully populated the domain list,
// set return parameters.
//
*pdwDomainCount = dwDomainCount;
plbiReturned = plbiAllotted;
plbiAllotted = NULL;
dwError = ERROR_SUCCESS;
Cleanup:
if( pchTrustedDomains != NULL ) {
LocalFree( pchTrustedDomains );
}
if( plbiAllotted != NULL ) {
LocalFree( plbiAllotted );
}
SetLastError( dwError );
return( plbiReturned );
}
#endif //OS_WIN32
#ifdef OS_WIN32
/****************************************************************************/
/* Name: LoadLibraries */
/* */
/* Purpose: Load the appropriate libraries for win95 and winnt. */
/* */
/* Returns: None */
/* */
/* Params: None */
/****************************************************************************/
void CBrowseServersCtl::LoadLibraries(void)
{
#ifndef OS_WINCE
OSVERSIONINFOA osVersionInfo;
osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
//A version to avoid wrapping
if(GetVersionExA(&osVersionInfo) == TRUE)
{
if(VER_PLATFORM_WIN32_WINDOWS == osVersionInfo.dwPlatformId )
{
bIsWin95 = TRUE;
if(!hLibrary)
{
hLibrary = LoadLibrary(__T("msnet32.dll"));
}
if(NULL == hLibrary)
return ;
lpfnNetServerEnum2 = (LPFNNETSERVERENUM2)GetProcAddress((HMODULE)hLibrary,
(LPCSTR)0x0029);
lpfnNetWkStaGetInfo = (LPFNNETWKSTAGETINFO)GetProcAddress((HMODULE)hLibrary,
(LPCSTR)0x0039);
}
else if(VER_PLATFORM_WIN32_NT == osVersionInfo.dwPlatformId )
{
if(!hLibrary)
{
hLibrary = LoadLibrary(__T("NetApi32.dll"));
}
if(NULL == hLibrary)
return;
lpfnNetServerEnum = (LPFNNETSERVERENUM)
GetProcAddress((HMODULE)hLibrary,
"NetServerEnum");
lpfnNetApiBufferFree = (LPFNNETAPIBUFFERFREE)
GetProcAddress((HMODULE)hLibrary,
"NetApiBufferFree");
lpfnNetWkStaGetInfo_NT = (LPFNNETWKSTAGETINFO_NT)GetProcAddress(
(HMODULE)hLibrary,
"NetWkstaGetInfo");
lpfnNetEnumerateTrustedDomains = (LPFNNETENUMERATETRUSTEDDOMAINS)
GetProcAddress((HMODULE)hLibrary,
"NetEnumerateTrustedDomains");
#ifdef UNICODE
lpfnDsGetDcName = (LPFNDSGETDCNAME)
GetProcAddress((HMODULE)hLibrary,
"DsGetDcNameW");
#else // UNICODE
lpfnDsGetDcName = (LPFNDSGETDCNAME)
GetProcAddress((HMODULE)hLibrary,
"DsGetDcNameA");
#endif // UNICODE
}
}
return;
#else
hLibrary = LoadLibrary(L"coredll.dll");
lpfnWNetOpenEnum = (LPFNWNETOPENENUM )
GetProcAddress((HMODULE)hLibrary,
L"WNetOpenEnumW");
lpfnWNetEnumResource = (LPFNWNETENUMRESOURCE )
GetProcAddress((HMODULE)hLibrary,
L"WNetEnumResourceW");
lpfnWNetCloseEnum = (LPFNWNETCLOSEENUM )
GetProcAddress((HMODULE)hLibrary,
L"WNetCloseEnum");
#endif
}
#endif //OS_WIN32
/****************************************************************************/
/* Name: ExpandDomain */
/* */
/* Purpose: Enumerates the Hydra Servers in a Domain/workgroup, adds */
/* them to the linked-list and as items in the list box. */
/* */
/* Returns: */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
int CBrowseServersCtl::ExpandDomain(HWND hwndDlg, TCHAR *pDomainName,
ServerListItem *plbi, DWORD *pdwIndex)
{
//
// check to see we are expanding a DNS domain.
//
if( plbi->bDNSDomain ) {
return( UIExpandDNSDomain( hwndDlg, pDomainName, plbi, pdwIndex ) );
}
//
// check to we are running on Win9x machine.
//
#ifndef OS_WINCE
if( bIsWin95 == TRUE) {
return( ExpandDomain95(hwndDlg, pDomainName, plbi, pdwIndex) );
}
else {
return( ExpandDomainNT(hwndDlg, pDomainName, plbi, pdwIndex) );
}
#else
return ExpandDomainCE(hwndDlg, pDomainName, plbi, pdwIndex);
#endif
}//ExpandDomain
/****************************************************************************/
/* Name: ExpandDomain95 */
/* */
/* Purpose: Enumerates the Hydra Servers in a Domain/workgroup, adds */
/* them to the linked-list and as items in the list box. */
/* */
/* Returns: */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
#ifdef OS_WIN32
#ifndef OS_WINCE
int CBrowseServersCtl::ExpandDomain95(HWND hwndDlg, TCHAR *pDomainName,
ServerListItem *plbi, DWORD *pdwIndex)
{
UNREFERENCED_PARAMETER(pDomainName);
DWORD dwIndex = *pdwIndex;
unsigned short AvailCount = 0, TotalEntries = 0;
ServerListItem *plbistore = NULL, *pItemsStore = NULL;
DCUINT index = 0, cb = 0;
struct server_info_1 *pInfo1 = NULL;
int err = 0;
int nCount = 0;
HWND hTree = NULL;
if(NULL == lpfnNetServerEnum2)
return 0;
SetCursor(LoadCursor(NULL, IDC_WAIT));
if(!plbi->ServerItems)
{
// Determine how much information is available
err = (*lpfnNetServerEnum2)(NULL, 1, NULL, 0, &AvailCount,
&TotalEntries, HYDRA_SERVER_LANMAN_BITS, NULL);
if(err != ERROR_MORE_DATA)
return 0;
// Allocate memory to receive the information
// Give a little extra, since sometimes one is missed
cb = (TotalEntries + 1) * sizeof(struct server_info_1);
pInfo1 = (struct server_info_1 *)LocalAlloc(0, cb);
if ( pInfo1 == NULL )
{
goto done1;
}
memset(pInfo1,0,cb);
//
// lpfnNetServerEnum2 is going to take a long time,
// Retrieve the information
err = (*lpfnNetServerEnum2)(
NULL,
1,
(char far *)pInfo1,
(unsigned short)cb,
&AvailCount,
&TotalEntries,
HYDRA_SERVER_LANMAN_BITS,
NULL);
// Due to the dynamic nature of the network, we may get
// ERROR_MORE_DATA, but that means we got the bulk of the
// correct values, and we should display them
if ((err != NERR_Success) && (err != ERROR_MORE_DATA))
goto done1;
//Allocate memory.
cb = sizeof(ServerListItem)*AvailCount;
plbi->ServerItems = (ServerListItem *)LocalAlloc(0, (sizeof(ServerListItem)*AvailCount));
if ( plbi->ServerItems == NULL )
{
goto done1;
}
memset(plbi->ServerItems,0,sizeof(ServerListItem)*AvailCount);
pItemsStore = plbi->ServerItems;
if(IsBadWritePtr((LPVOID)plbi->ServerItems,sizeof(ServerListItem)*AvailCount))
goto done1;
// Traverse list, copy servers to plbi.
for( index = 0; index < AvailCount; index++ )
{
if( ((pInfo1[index].sv1_version_major & MAJOR_VERSION_MASK) >=
4) && (pInfo1[index].sv1_version_minor >= 0) )
{
#ifdef UNICODE
nCount =
MultiByteToWideChar(
CP_ACP,
MB_COMPOSITE,
(LPSTR)pInfo1[index].sv1_name,
-1,
pItemsStore->ContainerName,
sizeof(pItemsStore->ContainerName)/sizeof(WCHAR));
if( nCount == 0 )
{
return 0;
}
#else
_tcscpy(pItemsStore->ContainerName, pInfo1[index].sv1_name);
#endif
if(pInfo1[index].sv1_comment != NULL)
{
#ifdef UNICODE
nCount =
MultiByteToWideChar(
CP_ACP,
MB_COMPOSITE,
(LPSTR)pInfo1[index].sv1_comment,
-1,
pItemsStore->Comment,
sizeof(pItemsStore->Comment)/sizeof(WCHAR));
if( nCount == 0 )
{
return 0;
}
#else
_tcscpy(pItemsStore->Comment, pInfo1[index].sv1_comment);
#endif
}
pItemsStore->bContainsServers = FALSE;
pItemsStore++;
plbi->nServerCount++;
}
}
done1:
if ( AvailCount && pInfo1 )
{
LocalFree( pInfo1 );
}
if(!plbi->ServerItems)
{
return 0;
}
}
else
AvailCount = (unsigned short)plbi->nServerCount;
// Traverse the plbi>ServerItems and add the servers to the List-box:
pItemsStore = plbi->ServerItems;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
HTREEITEM hTreeParentNode = plbi->hTreeItem;
for (index = 0; index < plbi->nServerCount; ++index)
{
if(hwndDlg)
{
if (DC_TSTRCMP(pItemsStore->ContainerName, _T("")))
{
pItemsStore->hTreeParentItem = hTreeParentNode;
pItemsStore->hTreeItem =
AddItemToTree(hTree, pItemsStore->ContainerName,
hTreeParentNode,
pItemsStore, SRV_TREE_SERVERLEVEL);
}
}
pItemsStore++;
}
plbi->bServersExpandedOnce = TRUE;
*pdwIndex = dwIndex;
if(hwndDlg)
{
InvalidateRect(hwndDlg, NULL, TRUE);
}
SetCursor(LoadCursor(NULL, IDC_ARROW));
return AvailCount;
}/* ExpandDomain95 */
/****************************************************************************/
/* Name: ExpandDomainNT */
/* */
/* Purpose: Enumerates the Hydra Servers in a Domain/workgroup, adds */
/* them to the linked-list and as items in the list box. */
/* */
/* Returns: */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
int CBrowseServersCtl::ExpandDomainNT(HWND hwndDlg, TCHAR *pDomainName,
ServerListItem *plbi, DWORD *pdwIndex)
{
DWORD dwIndex = *pdwIndex, AvailCount = 0, TotalEntries = 0;
SERVER_INFO_101 *pInfo = NULL;
DCUINT index = 0;
ServerListItem *plbistore = NULL, *pItemsStore = NULL;
WCHAR pDomain[BROWSE_MAX_ADDRESS_LENGTH];
int nCount = 0;
HWND hTree = NULL;
if(NULL == lpfnNetServerEnum)
return 0;
if(NULL == lpfnNetApiBufferFree)
return 0;
SetCursor(LoadCursor(NULL, IDC_WAIT));
if(plbi->ServerItems)
{
AvailCount = plbi->nServerCount;
}
else
{
//
//enumerate the servers in the primary domain if not already present
//
if(pDomainName)
{
#ifndef UNICODE
nCount = MultiByteToWideChar(CP_ACP,
MB_COMPOSITE,
pDomainName,
lstrlen(pDomainName) * sizeof(TCHAR),
(LPWSTR)pDomain,
sizeof(pDomain) / sizeof(TCHAR));
if(nCount)
{
pDomain[nCount] = 0;
}
else
{
AvailCount = 0;
goto done;
}
#else
_tcsncpy( pDomain, (LPTSTR)pDomainName,
sizeof(pDomain)/sizeof(TCHAR) - 1);
pDomain[sizeof(pDomain)/sizeof(TCHAR) - 1] = 0;
#endif
}
//
// lpfnNetServerEnum is going to take a long time,
//
if ((*lpfnNetServerEnum)(NULL,
101,
(LPBYTE *)&pInfo,
(DWORD) -1,
&AvailCount,
&TotalEntries,
HYDRA_SERVER_LANMAN_BITS,
pDomainName ?
(LPTSTR)pDomain :
NULL,
NULL ) || !AvailCount )
{
AvailCount = 0;
goto done;
}
//Allocate memory.
if ( (plbi->ServerItems = (ServerListItem *)LocalAlloc(0,
(sizeof(ServerListItem)*AvailCount))) == NULL )
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto done;
}
memset(plbi->ServerItems,0,sizeof(ServerListItem)*AvailCount);
pItemsStore = plbi->ServerItems;
// Traverse list, copy servers to plbi.
for( index = 0; index < AvailCount; index++ )
{
if( ((pInfo[index].sv101_version_major & MAJOR_VERSION_MASK) >=
4) )
{
#ifdef UNICODE
lstrcpy(pItemsStore->ContainerName, pInfo[index].sv101_name);
lstrcpy(pItemsStore->Comment, pInfo[index].sv101_comment);
#else
WideCharToMultiByte(CP_ACP,
WC_COMPOSITECHECK|WC_SEPCHARS,
(LPCWSTR)pInfo[index].sv101_name,
wcslen((const wchar_t *)pInfo[index].sv101_name),
pItemsStore->ContainerName,
sizeof(pItemsStore->ContainerName),
NULL,
NULL);
WideCharToMultiByte(CP_ACP,
WC_COMPOSITECHECK|WC_SEPCHARS,
(LPCWSTR)pInfo[index].sv101_comment,
wcslen((const wchar_t *)pInfo[index].sv101_comment),
pItemsStore->Comment,
sizeof(pItemsStore->Comment),
NULL,
NULL);
#endif
pItemsStore->bContainsServers = FALSE;
pItemsStore++;
plbi->nServerCount ++;
}
}
done:
if ( AvailCount && pInfo )
{
(*lpfnNetApiBufferFree)( pInfo );
}
}
// Traverse the plbi>ServerItems and add the servers to the List-box:
pItemsStore = plbi->ServerItems;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
HTREEITEM hTreeParentNode = plbi->hTreeItem;
for (index = 0; index < plbi->nServerCount;++index)
{
if(hwndDlg)
{
if (DC_TSTRCMP(pItemsStore->ContainerName, _T("")))
{
pItemsStore->hTreeParentItem = hTreeParentNode;
pItemsStore->hTreeItem =
AddItemToTree(hTree, pItemsStore->ContainerName,
hTreeParentNode,
pItemsStore, SRV_TREE_SERVERLEVEL);
}
}
plbi->bServersExpandedOnce = TRUE;
pItemsStore++;
}
*pdwIndex = dwIndex;
SetCursor(LoadCursor(NULL, IDC_ARROW));
return AvailCount;
} /* ExpandDomainNT */
#else
/****************************************************************************/
/* Name: ExpandDomainCE */
/* */
/* Purpose: Enumerates the Hydra Servers in a Domain/workgroup, adds */
/* them to the linked-list and as items in the list box. */
/* */
/* Returns: */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
int CBrowseServersCtl::ExpandDomainCE(HWND hwndDlg, TCHAR *pDomainName,
ServerListItem *plbi, DWORD *pdwIndex)
{
DWORD AvailCount = 0;
NETRESOURCE *pNetRsrc = NULL;
HWND hTree = NULL;
DWORD dwInitBufSize = 16*1024;
if((NULL == lpfnWNetOpenEnum) || (NULL == lpfnWNetCloseEnum) || (NULL == lpfnWNetEnumResource))
return 0;
SetCursor(LoadCursor(NULL, IDC_WAIT));
if(plbi->ServerItems)
{
AvailCount = plbi->nServerCount;
}
else
{
NETRESOURCE netrsrc;
HANDLE hEnum = NULL;
DWORD dwRet = NO_ERROR;
netrsrc.dwScope = RESOURCE_GLOBALNET;
netrsrc.dwType = RESOURCETYPE_ANY;
netrsrc.dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
netrsrc.dwUsage = RESOURCEUSAGE_CONTAINER;
netrsrc.lpLocalName = NULL;
netrsrc.lpRemoteName = pDomainName;
netrsrc.lpComment = NULL;
netrsrc.lpProvider = NULL;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
dwRet = lpfnWNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_RESERVED, HYDRA_SERVER_LANMAN_BITS, &netrsrc, &hEnum);
if ((dwRet != NO_ERROR) || (hEnum == NULL))
return 0;
AvailCount = 0;
pNetRsrc = (NETRESOURCE *)LocalAlloc(0, dwInitBufSize);
if (!pNetRsrc)
goto done;
while(dwRet == NO_ERROR)
{
DWORD dwCount, dwTempSize;
dwCount = 0xffffffff;
dwTempSize = dwInitBufSize;
dwRet = lpfnWNetEnumResource(hEnum, &dwCount, pNetRsrc, &dwTempSize);
if (dwRet == NO_ERROR)
{
AvailCount += dwCount;
for (DWORD i=0; i<dwCount; i++)
{
AddItemToTree(hTree, pNetRsrc[i].lpRemoteName,
plbi->hTreeItem,
NULL, SRV_TREE_SERVERLEVEL);
}
}
}
lpfnWNetCloseEnum(hEnum);
hEnum = NULL;
done:
if (pNetRsrc)
LocalFree(pNetRsrc);
lpfnWNetCloseEnum(hEnum);
}
SetCursor(LoadCursor(NULL, IDC_ARROW));
return AvailCount;
} /* ExpandDomainCE */
#endif
#endif //OS_WIN32
/****************************************************************************/
/* Name: UIGetTrustedDomains */
/* */
/* Purpose: Queries teh registry for a list of the Trusted Domains */
/* */
/* Returns: */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
#ifdef OS_WIN32
#ifndef OS_WINCE
PDCTCHAR CBrowseServersCtl::UIGetTrustedDomains()
{
HKEY hKey = NULL;
DWORD size = 0 , size1 = 0;
PDCTCHAR pTrustedDomains = NULL;
PDCTCHAR pPutHere = NULL;
PDCTCHAR szPrimaryDomain = NULL;
PDCTCHAR szWkstaDomainName = NULL;
PDCTCHAR pDomain = NULL;
BOOL bGetTrustedDomains = FALSE;
OSVERSIONINFOA OsVer;
memset(&OsVer, 0x0, sizeof(OSVERSIONINFOA));
OsVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
GetVersionExA(&OsVer);
if(OsVer.dwMajorVersion <= 4)
{
// Get the current domain information from the winlogon settings.
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, DOMAIN_KEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
DWORD dwResult = 0;
dwResult = RegQueryValueEx(hKey, PRIMARY_VAL, NULL, NULL, NULL, &size);
if (dwResult == ERROR_SUCCESS && size > 0)
{
szPrimaryDomain = (PDCTCHAR)LocalAlloc(LPTR, (size + 1)*sizeof(TCHAR));
if (szPrimaryDomain == NULL)
{
goto Cleanup;
}
if ((RegQueryValueEx(
hKey,
PRIMARY_VAL,
NULL, NULL,
(LPBYTE)szPrimaryDomain,
&size
) == ERROR_SUCCESS) &&
szPrimaryDomain[0])
{
pDomain = szPrimaryDomain;
}
}
}
}
else
{
if(NULL == lpfnDsGetDcName)
return 0;
DOMAIN_CONTROLLER_INFO *pDCI = NULL;
// this section gets the current domain the app is running on
if((*lpfnDsGetDcName)(NULL, NULL, NULL,
NULL, DS_RETURN_FLAT_NAME,
&pDCI ) == NO_ERROR)
{
pDomain = pDCI->DomainName;
}
}
// Get the domain/work group information from NetWkStaGetInfo
if (lpfnNetWkStaGetInfo_NT)
{
LPBYTE buffer = NULL;
if ((*lpfnNetWkStaGetInfo_NT)(NULL, 100, &buffer) == NERR_Success && buffer)
{
LPWSTR langroup = ((WKSTA_INFO_100 *)buffer)->wki100_langroup;
DWORD langroupLen = (langroup) ? wcslen(langroup) : 0;
if (langroupLen)
{
szWkstaDomainName = (PDCTCHAR)LocalAlloc(LPTR, (langroupLen + 1)*sizeof(TCHAR));
if (szWkstaDomainName == NULL)
{
goto Cleanup;
}
#ifdef UNICODE
_tcscpy(szWkstaDomainName,langroup);
pDomain = szWkstaDomainName;
#else
// convert the unicode string to ansi
if (WideCharToMultiByte(CP_ACP,
0,
langroup,
-1,
szWkstaDomainName,
(langroupLen + 1) * sizeof(TCHAR),
NULL,
NULL))
{
pDomain = szWkstaDomainName;
}
#endif
}
if (lpfnNetApiBufferFree)
{
(*lpfnNetApiBufferFree)(buffer);
}
}
}
//
// We should get the list of trusted domains only when the machine belongs to a domain, not a workgroup
// We determine that the machine belongs to a domain if the winlogon cached information, and the langroup from
// NetWkstaGetInfo match.
//
if (szPrimaryDomain &&
szPrimaryDomain[0] &&
szWkstaDomainName &&
_tcscmp(szPrimaryDomain, szWkstaDomainName) == 0)
{
bGetTrustedDomains = TRUE;
}
size = (pDomain) ? _tcslen(pDomain) : 0;
if(size > 0)
{
if (bGetTrustedDomains && hKey != NULL && (OsVer.dwMajorVersion < 4))
{
if(ERROR_SUCCESS == RegQueryValueEx(hKey, CACHE_VAL_NT351,
NULL, NULL,
NULL, &size1))
{
pTrustedDomains = (PDCTCHAR)LocalAlloc(LPTR, (size + size1 + 2) * sizeof(TCHAR));
if(NULL == pTrustedDomains)
goto Cleanup;
_tcscpy(pTrustedDomains, pDomain);
pPutHere = pTrustedDomains;
pPutHere += (_tcslen(pTrustedDomains) + 1);
*pPutHere = _T('\0');
}
else
{
goto Cleanup;
}
}
else if (bGetTrustedDomains && hKey != NULL && (4 == OsVer.dwMajorVersion) )
{
if(ERROR_SUCCESS == RegQueryValueEx(hKey, CACHE_VAL,
NULL, NULL,
NULL, &size1))
{
pTrustedDomains = (PDCTCHAR)LocalAlloc(LPTR, (size + size1 + 2) * sizeof(TCHAR));
if(NULL == pTrustedDomains)
goto Cleanup;
_tcscpy(pTrustedDomains, pDomain);
pPutHere = pTrustedDomains;
pPutHere += (_tcslen(pTrustedDomains) + 1);
*pPutHere = _T('\0');
RegQueryValueEx(hKey, CACHE_VAL, NULL, NULL, (LPBYTE)pPutHere, &size1);
}
}
else if (5 <= OsVer.dwMajorVersion)
{
LPWSTR szDomainNames = NULL;
if(NULL == lpfnNetEnumerateTrustedDomains)
goto Cleanup;
size1 = 0;
DWORD dwCount;
LPWSTR szWideBuf = NULL;
if( (*lpfnNetEnumerateTrustedDomains)(NULL,
&szDomainNames ) == ERROR_SUCCESS )
{
szWideBuf = szDomainNames;
while(*szWideBuf && (*szWideBuf+1))
{
size1 += wcslen(szWideBuf) + 1;
szWideBuf += wcslen(szWideBuf) + 1;
}
szWideBuf = szDomainNames;
}
pTrustedDomains = (PDCTCHAR)LocalAlloc(LPTR, (size + size1 + 2) * sizeof(TCHAR));
if(NULL == pTrustedDomains)
goto Cleanup;
_tcscpy(pTrustedDomains, pDomain);
pPutHere = pTrustedDomains + _tcslen(pTrustedDomains) + 1;
*pPutHere = _T('\0');
if(size1)
{
//
// CONVERT unicode domain name to ansi.
//
while(*szWideBuf && (*szWideBuf+1))
{
#ifndef UNICODE
WideCharToMultiByte(CP_ACP, 0, szWideBuf, -1,
pPutHere, wcslen(szWideBuf) * sizeof(TCHAR), NULL, NULL );
#else // UNICODE
lstrcpy(pPutHere, szWideBuf);
#endif //UNICODE
pPutHere += _tcslen(pPutHere);
*pPutHere++ = 0;
szWideBuf += wcslen(szWideBuf) + 1;
}
if(NULL == lpfnNetApiBufferFree)
return 0;
(*lpfnNetApiBufferFree)( szDomainNames );
}
}
}
Cleanup:
if (hKey)
{
RegCloseKey(hKey);
}
if (szPrimaryDomain)
{
LocalFree(szPrimaryDomain);
}
if (szWkstaDomainName)
{
LocalFree(szWkstaDomainName);
}
return pTrustedDomains;
}
#else
PDCTCHAR CBrowseServersCtl::UIGetTrustedDomains()
{
HKEY hKey = NULL;
DWORD size = 0;
PDCTCHAR szPrimaryDomain = NULL;
PDCTCHAR pTrustedDomains = NULL;
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, DOMAIN_KEY, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
DWORD dwResult = 0;
dwResult = RegQueryValueEx(hKey, PRIMARY_VAL, NULL, NULL, NULL, &size);
if (dwResult == ERROR_SUCCESS && size > 0)
{
szPrimaryDomain = (PDCTCHAR)LocalAlloc(LPTR, (size + 1)*sizeof(TCHAR));
if (szPrimaryDomain == NULL)
{
RegCloseKey(hKey);
return NULL;
}
if ((RegQueryValueEx(
hKey,
PRIMARY_VAL,
NULL, NULL,
(LPBYTE)szPrimaryDomain,
&size
) == ERROR_SUCCESS) &&
szPrimaryDomain[0])
{
pTrustedDomains = szPrimaryDomain;
}
else
{
LocalFree(szPrimaryDomain);
}
}
}
return pTrustedDomains;
}
#endif
#endif //OS_WIN32
/* UIGetTrustedDomains */
/****************************************************************************/
/* Name: UIExpandDNSDomain */
/* */
/* Purpose: Enumerates the Hydra Servers in a DNS Domain, adds */
/* them to the linked-list and as items in the list box. */
/* */
/* Returns: numbers of server expanded */
/* */
/* Params: HWND hwndDlg Handle to the dialogwindow containing the list-box */
/****************************************************************************/
int
CBrowseServersCtl::UIExpandDNSDomain(
HWND hwndDlg,
TCHAR *pDomainName,
ServerListItem *plbi,
DWORD *pdwIndex
)
{
DWORD dwError;
LPHOSTENT lpHostEnt;
LPHOSTENT lpRevHostEnt;
DWORD dwIPEntries;
LPSTR FAR *lplpIPEntry;
DWORD FAR *lpIPAddrsAlloted = NULL;
DWORD FAR *lpIPAddrs;
ServerListItem *lpServerListItem = NULL;
ServerListItem *lpLBItem;
DWORD i;
DWORD dwEntriesDisplayed = 0;
HWND hTree = NULL;
HTREEITEM hTreeParentNode = NULL;
//
// set cursor to wait cursor while we do this.
//
SetCursor(LoadCursor(NULL, IDC_WAIT));
//
// check to see the specified list box entry is server entry.
//
// TRC_ASSERT((plbi->bContainsServers == TRUE),
// (TB,"Not a server entry"));
if( plbi->bContainsServers == FALSE ) {
dwError = ERROR_INVALID_DATA;
goto Cleanup;
}
if( hwndDlg == NULL ) {
dwError = ERROR_INVALID_DATA;
goto Cleanup;
}
//
// resolve the DNS domain name if it is not done before.
//
if( plbi->ServerItems == NULL ) {
#ifdef UNICODE
WCHAR achDomainName[BROWSE_MAX_ADDRESS_LENGTH];
DWORD dwCount;
//
// CONVERT unicode domain name to ansi.
//
dwCount =
WideCharToMultiByte(
CP_ACP,
WC_COMPOSITECHECK | WC_SEPCHARS,
pDomainName,
-1,
(LPSTR)achDomainName,
sizeof(achDomainName),
NULL,
NULL);
if( dwCount == 0 ) {
dwError = GetLastError();
goto Cleanup;
}
achDomainName[dwCount/sizeof(TCHAR)]= '\0';
lpHostEnt = gethostbyname( (LPSTR)achDomainName );
#else // UNICODE
//
// resolve the domain name to ip address list.
//
lpHostEnt = gethostbyname( pDomainName );
#endif // UNICODE
if( lpHostEnt == NULL ) {
dwError = GetLastError();
goto Cleanup;
}
//
// we handle only IP address type.
//
/*
TRC_ASSERT((lpHostEnt->h_addrtype == PF_INET),
(TB,"Invalid address type"));
TRC_ASSERT((lpHostEnt->h_length == 4),
(TB,"Invalid address length"));
*/
if( (lpHostEnt->h_addrtype != PF_INET) ||
(lpHostEnt->h_length != 4) ) {
dwError = ERROR_INVALID_DATA;
goto Cleanup;
}
dwIPEntries = 0;
lplpIPEntry = lpHostEnt->h_addr_list;
while( *lplpIPEntry != NULL ) {
dwIPEntries++;
lplpIPEntry++;
}
//
// allocate memory for the ip address list and
// save for further use in this routine (only).
//
// Note: lpHostEnt points to a thread storeage
// which is reused by gethostbyname() and
// gethostbyaddr() calls with in the same
// thread, since we need to call gethostbyaddr()
// we better save the address list.
//
lpIPAddrsAlloted =
lpIPAddrs = (DWORD FAR *)
LocalAlloc( LMEM_FIXED, sizeof(DWORD) * dwIPEntries );
if( lpIPAddrs == NULL ) {
dwError = ERROR_OUTOFMEMORY;
goto Cleanup;
}
lplpIPEntry = lpHostEnt->h_addr_list;
while( *lplpIPEntry != NULL ) {
*lpIPAddrs = *(DWORD *)(*lplpIPEntry);
lpIPAddrs++;
lplpIPEntry++;
}
//
// allocate memory for domain ServerListItem array.
//
lpLBItem =
lpServerListItem = (ServerListItem *)
LocalAlloc( LMEM_FIXED, dwIPEntries * sizeof(ServerListItem) );
if( lpServerListItem == NULL ) {
dwError = ERROR_OUTOFMEMORY;
goto Cleanup;
}
//
// reverse resolve each ip address and get the name.
//
lpIPAddrs = lpIPAddrsAlloted;
for( i = 0; i < dwIPEntries; i++ ) {
CHAR achContainerName[BROWSE_MAX_ADDRESS_LENGTH];
int nCount;
BOOL bIPAddressString = FALSE;
lpRevHostEnt =
gethostbyaddr(
(LPSTR)lpIPAddrs,
sizeof(*lpIPAddrs),
PF_INET );
//
// if we can not reverse resolve the address or
// if the host name is too long, or
// display the ipaddress.
//
if( (lpRevHostEnt == NULL) ||
((strlen(lpRevHostEnt->h_name) + 1) >
(BROWSE_MAX_ADDRESS_LENGTH/sizeof(TCHAR)) ) ) {
bIPAddressString = TRUE;
}
else {
LPSTR lpszDomainName;
#ifdef UNICODE
lpszDomainName = (LPSTR)achDomainName;
#else // UNICODE
lpszDomainName = pDomainName;
#endif // UNICODE
//
// the resolved name is same of the orginal name,
// display the ipaddress.
//
//
// compare the entire name first.
//
if( _stricmp(
lpRevHostEnt->h_name,
lpszDomainName ) != 0 ) {
LPSTR lpszDotPostion1;
LPSTR lpszDotPostion2;
DWORD dwCmpLen = 0;
//
// compare the only the first part of the name.
//
lpszDotPostion1 = strchr( lpRevHostEnt->h_name, '.');
lpszDotPostion2 = strchr( lpszDomainName, '.');
if( (lpszDotPostion1 == NULL) &&
(lpszDotPostion2 != NULL) ) {
dwCmpLen = (DWORD)(lpszDotPostion2 - lpszDomainName);
}
else if( (lpszDotPostion1 != NULL) &&
(lpszDotPostion2 == NULL) ) {
dwCmpLen = (DWORD)(lpszDotPostion1 -
lpRevHostEnt->h_name);
}
if( dwCmpLen != 0 ) {
if( _strnicmp(
lpRevHostEnt->h_name,
lpszDomainName,
(size_t)dwCmpLen ) == 0 ) {
bIPAddressString = TRUE;
}
}
}
else {
bIPAddressString = TRUE;
}
}
if( bIPAddressString ) {
strcpy(
(LPSTR)achContainerName,
inet_ntoa( *(struct in_addr *)lpIPAddrs ));
}
else {
strcpy( (LPSTR)achContainerName, lpRevHostEnt->h_name);
}
#ifdef UNICODE
//
// convert to UNICODE.
//
nCount =
MultiByteToWideChar(
CP_ACP,
MB_COMPOSITE,
(LPSTR)achContainerName,
-1,
lpLBItem->ContainerName,
sizeof(lpLBItem->ContainerName)/sizeof(WCHAR));
if( nCount == 0 ) {
dwError = GetLastError();
goto Cleanup;
}
//
// terminate converted string.
//
lpLBItem->ContainerName[nCount] = _T('\0');
#else // UNICODE
strcpy( lpLBItem->ContainerName, (LPSTR)achContainerName );
#endif // UNICODE
lpLBItem->Comment[0] = _T('\0');
lpLBItem->bContainsServers = FALSE;;
lpLBItem->bServersExpandedOnce = FALSE;
lpLBItem->bDNSDomain = FALSE;
lpLBItem->nServerCount = 0;
lpLBItem->ServerItems = NULL;
//
// move to next entry.
//
lpLBItem++;
lpIPAddrs++;
}
//
// Hook the allotted ServerListItem to the server
// structure, it will be used in future.
//
plbi->ServerItems = lpServerListItem;
plbi->nServerCount = dwIPEntries;
//
// set lpServerListItem to NULL, so that
// it will not get freed.
//
lpServerListItem = NULL;
}
//
// When we are here ..
//
// plbi->ServerItems points to the servers ServerListItem array
// and plbi->nServerCount has the count.
//
//
// display entires.
//
lpLBItem = plbi->ServerItems;
hTree = GetDlgItem( hwndDlg, UI_IDC_SERVERS_TREE );
hTreeParentNode = plbi->hTreeItem;
for( i = 0; i < plbi->nServerCount; i++ ) {
lpLBItem->hTreeParentItem = hTreeParentNode;
lpLBItem->hTreeItem =
AddItemToTree(hTree, lpLBItem->ContainerName,
hTreeParentNode,
lpLBItem, SRV_TREE_SERVERLEVEL);
lpLBItem++;
}
//
// Refresh the dialog box.
//
InvalidateRect(hwndDlg, NULL, TRUE);
plbi->bServersExpandedOnce = TRUE;
dwEntriesDisplayed = plbi->nServerCount;
//
// We are done.
//
dwError = ERROR_SUCCESS;
Cleanup:
if( lpIPAddrsAlloted != NULL ) {
LocalFree( lpIPAddrsAlloted );
}
if( lpServerListItem != NULL ) {
LocalFree( lpServerListItem );
}
if( dwError != ERROR_SUCCESS ) {
//TRC_NRM((TB, "UIExpandDNSDomain failed, %ld", dwError));
}
SetLastError( dwError );
SetCursor(LoadCursor(NULL, IDC_ARROW));
return( dwEntriesDisplayed );
}
#ifdef OS_WIN32
DWORD WINAPI CBrowseServersCtl::UIStaticPopListBoxThread(LPVOID lpvThreadParm)
{
DWORD dwRetVal=0;
//TRC_ASSERT(lpvThreadParm, (TB, "Thread param is NULL (instance pointer should be set)\n"));
if(lpvThreadParm)
{
CBrowseServersCtl* pBrowseSrv = (CBrowseServersCtl*)lpvThreadParm;
dwRetVal = pBrowseSrv->UIPopListBoxThread(NULL);
}
return dwRetVal;
}
/****************************************************************************/
/* Name: UIPopListBoxThread */
/* */
/* Purpose: Thread function to populate the list box. */
/* */
/* Returns: Success/Failure of the function */
/* */
/* Params: */
/* */
/****************************************************************************/
DWORD WINAPI CBrowseServersCtl::UIPopListBoxThread(LPVOID lpvThreadParm)
{
DWORD dwResult = 0;
ServerListItem *pBrowsePlbi = NULL, *ptempList = NULL;
DCUINT browseCount = 0;
DC_IGNORE_PARAMETER(lpvThreadParm);
// TRC_ASSERT( _hwndDialog, (TB, "_hwndDialog is not set\n"));
PostMessage(_hwndDialog, UI_LB_POPULATE_START, 0, 0);
LoadLibraries();
pBrowsePlbi = PopulateListBox( _hwndDialog, &browseCount);
//message is posted to the main thread to notify that the listbox has been populated
PostMessage(_hwndDialog, UI_LB_POPULATE_END, 0, 0);
//wait for the event to be signalled when the "connect server" dialog box is destroyed
if(_hEvent)
{
DWORD dwRetVal;
dwRetVal = WaitForSingleObject(_hEvent, INFINITE);
if(WAIT_FAILED == dwRetVal)
{
/// TRC_ASSERT(WAIT_FAILED != dwRetVal, (TB, "Wait failed\n"));
}
if(!CloseHandle(_hEvent))
{
DWORD dwLastErr = GetLastError();
// TRC_ABORT((TB, "Close handle failed: GetLastError=%d\n",dwLastErr));
}
}
ptempList = pBrowsePlbi;
//free the ServerListItems and memory to linked-list
if(pBrowsePlbi)
{
while(browseCount)
{
if(ptempList->ServerItems)
{
LocalFree((HANDLE)ptempList->ServerItems);
}
ptempList++;
browseCount --;
}
LocalFree((HLOCAL)pBrowsePlbi);
}
//decrement ref count for this object held by this thread
Release();
return (dwResult);
} /*UIPopListBoxThread*/
#endif /* OS_WIN32 */
HTREEITEM CBrowseServersCtl::AddItemToTree( HWND hwndTV, LPTSTR lpszItem,
HTREEITEM hParent,
ServerListItem* pItem,
int nLevel)
{
TVITEM tvi;
TVINSERTSTRUCT tvins;
#ifndef OS_WINCE
HTREEITEM hti;
#endif
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE |TVIF_SELECTEDIMAGE;
if(nLevel == SRV_TREE_DOMAINLEVEL)
{
//
// Assume all domains have child servers
// they won't actually be enumerated until
// the user tries to expand the nodes
//
tvi.mask |= TVIF_CHILDREN;
tvi.cChildren = 1; //min number of children, will be updated
tvi.iImage = _nDomainImage;
tvi.iSelectedImage = _nDomainImage;
}
else
{
tvi.iImage = _nServerImage;
tvi.iSelectedImage = _nServerImage;
}
// Set the text of the item.
tvi.pszText = lpszItem;
tvi.cchTextMax = lstrlen(lpszItem);
// Save the ServerListItem info in the user defined area
// data area.
tvi.lParam = (LPARAM) pItem;
tvins.item = tvi;
tvins.hInsertAfter = _hPrev;
// Set the parent item based on the specified level.
tvins.hParent = hParent;
// Add the item to the tree view control.
_hPrev = (HTREEITEM) SendMessage(hwndTV, TVM_INSERTITEM, 0,
(LPARAM) (LPTVINSERTSTRUCT) &tvins);
// Save the handle to the item.
if (nLevel == SRV_TREE_DOMAINLEVEL)
_hPrevRootItem = _hPrev;
else if (nLevel == SRV_TREE_SERVERLEVEL)
_hPrevLev2Item = _hPrev;
return _hPrev;
}
//
//Handle TVN_ITEMEXPANDING
//
// On first expansion of a domain node, enumerate
// all the servers in that node and add them to the
// tree. Subsequent expands/collapses will just be handled
// by the tree.
//
// Return TRUE to allow expansion
// false otherwise
//
BOOL CBrowseServersCtl::OnItemExpanding(HWND hwndDlg, LPNMTREEVIEW nmTv)
{
ServerListItem* pSrvItem = NULL;
if(nmTv &&
(TVE_EXPAND == nmTv->action) &&
(nmTv->itemNew.mask & TVIF_PARAM))
{
//
// Expanding, need to build the list
// of servers for this domain
//
pSrvItem = (ServerListItem*)nmTv->itemNew.lParam;
if(pSrvItem)
{
//
// Only expanddomain if we've never expanded this node
// before
//
if(!pSrvItem->bServersExpandedOnce)
{
//Attempt to expand the domain
DWORD cItems = 0;
if(ExpandDomain( hwndDlg, pSrvItem->ContainerName,
pSrvItem, (DWORD*)&cItems))
{
return TRUE;
}
else
{
//
// Pop a message explaining that
// there are no TS's in this domain
//
UINT intRC;
TCHAR noTerminalServer[MAX_PATH];
intRC = LoadString(_hInst,
UI_IDS_NO_TERMINAL_SERVER,
noTerminalServer,
MAX_PATH);
if(intRC)
{
TCHAR title[MAX_PATH];
intRC = LoadString(_hInst,
UI_IDS_APP_NAME,
title,
MAX_PATH);
if(intRC)
{
DCTCHAR szBuffer[MAX_PATH +
BROWSE_MAX_ADDRESS_LENGTH];
_stprintf(szBuffer, noTerminalServer,
pSrvItem->ContainerName);
MessageBox( hwndDlg, szBuffer, title,
MB_OK | MB_ICONINFORMATION);
}
}
return FALSE;
}
}
else
{
//Already expanded so everythign is cached
//and ready to go, allow expansion
return TRUE;
}
}
else
{
return FALSE;
}
}
else
{
//Allow everythign else to expand
return TRUE;
}
}
BOOL CBrowseServersCtl::OnNotify( HWND hwndDlg, WPARAM wParam, LPARAM lParam)
{
LPNMHDR pnmh = (LPNMHDR) lParam;
if(pnmh)
{
switch( pnmh->code)
{
case TVN_ITEMEXPANDING:
{
return OnItemExpanding(
hwndDlg, (LPNMTREEVIEW) lParam);
}
break;
}
}
return TRUE;
}
#ifndef OS_WINCE
//
// Returns currently selected server
// or false if current selection is not a server but a domain
//
BOOL CBrowseServersCtl::GetServer(LPTSTR szServer, int cchLen)
{
HTREEITEM hti;
HWND hTree;
if(!_hwndDialog)
{
return FALSE;
}
hTree = GetDlgItem( _hwndDialog, UI_IDC_SERVERS_TREE );
hti = TreeView_GetSelection( hTree );
if( hti )
{
TVITEM item;
item.hItem = hti;
item.mask = TVIF_PARAM;
if(TreeView_GetItem( hTree, &item))
{
ServerListItem* ps = (ServerListItem*)item.lParam;
if(ps && !ps->bContainsServers)
{
_tcsncpy( szServer, ps->ContainerName, cchLen);
return TRUE;
}
}
}
return FALSE;
}
#else
BOOL CBrowseServersCtl::GetServer(LPTSTR szServer, int cchLen)
{
HTREEITEM hti;
HWND hTree;
if(!_hwndDialog)
{
return FALSE;
}
hTree = GetDlgItem( _hwndDialog, UI_IDC_SERVERS_TREE );
hti = TreeView_GetSelection( hTree );
if( hti )
{
TVITEM item;
item.hItem = hti;
item.mask = TVIF_TEXT | TVIF_PARAM;;
item.pszText = szServer;
item.cchTextMax = cchLen;
if(TreeView_GetItem( hTree, &item))
{
_tcsncpy( szServer, item.pszText, item.cchTextMax);
return TRUE;
}
}
return FALSE;
}
#endif