//
// 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