#include "pch.h"
#include "lm.h"       // NET_API_STATUS
#include <dsgetdc.h>  // DsEnumerateDomainTrusts
#include <subauth.h>
#include <ntlsa.h>    // TRUST_TYPE_XXX

#pragma hdrstop


/*-----------------------------------------------------------------------------
/ Misc data
/----------------------------------------------------------------------------*/

//
// Globally cached domain list, this is cached an free'd as required
//

PDOMAIN_TREE g_pDomainTree = NULL;
DWORD        g_dwFlags = 0;

//
// CDsBrowseDomainTree
//

class CDsDomainTreeBrowser : public IDsBrowseDomainTree
{
private:
    STDMETHODIMP _GetDomains(PDOMAIN_TREE *ppDomainTree, DWORD dwFlags);

    LONG _cRef;
    LPWSTR _pComputerName;
    LPWSTR _pUserName;
    LPWSTR _pPassword;
    LPDOMAINTREE _pDomainTree;
    DWORD  _dwFlags;

public:
    CDsDomainTreeBrowser();
    ~CDsDomainTreeBrowser();

    // IUnknown members
    STDMETHODIMP_(ULONG) AddRef();
    STDMETHODIMP_(ULONG) Release();
    STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObject);

    // IDsBrowseDomainTree
    STDMETHODIMP BrowseTo(HWND hwndParent, LPWSTR *ppszTargetPath, DWORD dwFlags);
    STDMETHODIMP GetDomains(PDOMAIN_TREE *ppDomainTree, DWORD dwFlags);
    STDMETHODIMP FreeDomains(PDOMAIN_TREE* ppDomainTree);
    STDMETHODIMP FlushCachedDomains();
    STDMETHODIMP SetComputer(LPCWSTR pComputerName, LPCWSTR pUserName, LPCWSTR pPassword);
};


CDsDomainTreeBrowser::CDsDomainTreeBrowser() :
    _cRef(1),
    _pComputerName(NULL),
    _pUserName(NULL),
    _pPassword(NULL),
    _pDomainTree(NULL),
    _dwFlags(0)
{
    DllAddRef();
}


CDsDomainTreeBrowser::~CDsDomainTreeBrowser()
{
    FreeDomains(&_pDomainTree);
    LocalFreeStringW(&_pComputerName);                                    
    LocalFreeStringW(&_pUserName);
    LocalFreeStringW(&_pPassword);
    DllRelease();
}


// IUnknown

ULONG CDsDomainTreeBrowser::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

ULONG CDsDomainTreeBrowser::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

HRESULT CDsDomainTreeBrowser::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = 
    {
        QITABENT(CDsDomainTreeBrowser, IDsBrowseDomainTree), // IID_IID_IDsBrowseDomainTree
        {0, 0 },
    };
    return QISearch(this, qit, riid, ppv);
}


//
// handle create instance
//

STDAPI CDsDomainTreeBrowser_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
    CDsDomainTreeBrowser *pddtb = new CDsDomainTreeBrowser();
    if ( !pddtb )
        return E_OUTOFMEMORY;

    HRESULT hres = pddtb->QueryInterface(IID_IUnknown, (void **)ppunk);
    pddtb->Release();
    return hres;
}

//---------------------------------------------------------------------------//
// IDsBrowseDomainTree
//---------------------------------------------------------------------------//

STDMETHODIMP CDsDomainTreeBrowser::SetComputer(LPCWSTR pComputerName, LPCWSTR pUserName, LPCWSTR pPassword)
{
    HRESULT hres;

    TraceEnter(TRACE_DOMAIN, "CDsDomainTreeBrowser::SetComputer");

    LocalFreeStringW(&_pComputerName);                                    
    LocalFreeStringW(&_pUserName);
    LocalFreeStringW(&_pPassword);

    hres = LocalAllocStringW(&_pComputerName, pComputerName);
    if ( SUCCEEDED(hres) )
        hres = LocalAllocStringW(&_pUserName, pUserName);
    if ( SUCCEEDED(hres) )
        hres = LocalAllocStringW(&_pPassword, pPassword);

    if ( FAILED(hres) )
    {
        LocalFreeStringW(&_pComputerName);                                    
        LocalFreeStringW(&_pUserName);
        LocalFreeStringW(&_pPassword);
    }

    TraceLeaveResult(hres);
}
      
//---------------------------------------------------------------------------//

#define BROWSE_CTX_HELP_FILE              _T("dsadmin.hlp")
#define IDH_DOMAIN_TREE                   300000800

const DWORD aBrowseHelpIDs[] =
{
  IDC_DOMAIN_TREE,IDH_DOMAIN_TREE,
  0, 0
};

struct DIALOG_STUFF 
{
    LPWSTR pszName;    // domain name (if no dns, use netbios)
    LPWSTR pszNCName;  // FQDN
    PDOMAIN_TREE pDomains;
};

//
// recursive tree filling stuff
//

HTREEITEM
_AddOneItem( HTREEITEM hParent, LPWSTR szText, HTREEITEM hInsAfter,
                      int iImage, int cChildren, HWND hwndTree, LPARAM Domain)
{
    HTREEITEM hItem;
    TV_ITEM tvI = { 0 };
    TV_INSERTSTRUCT tvIns = { 0 };
    USES_CONVERSION;

    // The .pszText, .iImage, and .iSelectedImage are filled in.
    tvI.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM;
    tvI.pszText = W2T(szText);
    tvI.cchTextMax = lstrlen(tvI.pszText);
    tvI.iImage = iImage;
    tvI.iSelectedImage = iImage;
    tvI.cChildren = cChildren;
    tvI.lParam = Domain;

    tvIns.item = tvI;
    tvIns.hInsertAfter = hInsAfter;
    tvIns.hParent = hParent;

    return TreeView_InsertItem(hwndTree, &tvIns);;
}

void
_AddChildren(DOMAIN_DESC *pDomain, HWND hTree, HTREEITEM hParent)
{
    DOMAIN_DESC * pChild = pDomain->pdChildList;
    for ( pChild = pDomain->pdChildList ; pChild ; pChild = pChild->pdNextSibling )
    {
        HTREEITEM hThis = _AddOneItem (hParent, pChild->pszName, TVI_SORT, 0, 
                                (pChild->pdChildList ? 1 : 0), hTree, (LPARAM)pChild);        
        if (pChild->pdChildList != NULL) 
            _AddChildren (pChild, hTree, hThis);
    }
}

//
// DlgProc for the simple browser
//

INT_PTR CALLBACK
_BrowserDlgProc (HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    HWND hTree = GetDlgItem (hwnd, IDC_DOMAIN_TREE);
    DIALOG_STUFF *pDialogInfo = (DIALOG_STUFF *)GetWindowLongPtr(hwnd, DWLP_USER);

    switch (Msg) 
    {
        case WM_INITDIALOG:
        {
            pDialogInfo = (DIALOG_STUFF *)lParam;
            PDOMAIN_TREE pDomains = pDialogInfo->pDomains;
            SetWindowLongPtr(hwnd, DWLP_USER, lParam);

            // assume all images are the same for the tree view so load it and set accordingly

            CLASSCACHEENTRY *pcce = NULL;
            CLASSCACHEGETINFO ccgi = { 0 };
            HICON hIcon = NULL;

            ccgi.dwFlags = CLASSCACHE_ICONS;
            ccgi.pObjectClass = pDomains->aDomains[0].pszObjectClass;

//  should be pasing computer name to get correct display specifier
//  ccgi.pServer = _pComputerName;

            if ( SUCCEEDED(ClassCache_GetClassInfo(&ccgi, &pcce)) )
            {
                WCHAR szBuffer[MAX_PATH];
                INT resid;

                HRESULT hres = _GetIconLocation(pcce, DSGIF_GETDEFAULTICON, szBuffer, ARRAYSIZE(szBuffer), &resid);
                ClassCache_ReleaseClassInfo(&pcce);

                if ( hres == S_OK )
                {
                    HICON hIcon;
                    INT cxSmIcon = GetSystemMetrics(SM_CXSMICON);
                    INT cySmIcon = GetSystemMetrics(SM_CYSMICON);
               
                    if ( 1 == PrivateExtractIcons(szBuffer, resid, cxSmIcon, cySmIcon, &hIcon, NULL, 1, LR_LOADFROMFILE) )
                    {
                        HIMAGELIST himl = ImageList_Create(cxSmIcon, cySmIcon, ILC_COLOR|ILC_MASK, 0, 1);
                        if ( himl )
                        {
                            ImageList_AddIcon(himl, hIcon);
                            TreeView_SetImageList(hTree, himl, TVSIL_NORMAL);
                        }

                        DestroyIcon(hIcon);
                    }
                }
            }

            // now populate the tree with the items in the domain structure

            for (PDOMAIN_DESC pRootDomain = pDomains->aDomains; pRootDomain; pRootDomain = pRootDomain->pdNextSibling)
            {
                HTREEITEM hRoot = _AddOneItem(TVI_ROOT, pRootDomain->pszName, TVI_SORT, 0,
                                        (pRootDomain->pdChildList ? 1 : 0), hTree, (LPARAM) pRootDomain);

                if (pRootDomain->pdChildList != NULL)
                    _AddChildren(pRootDomain, hTree, hRoot);

            }

            return TRUE;
        }

        case WM_HELP:
        {
            WinHelp((HWND)(((LPHELPINFO)lParam)->hItemHandle),
                            BROWSE_CTX_HELP_FILE,
                            HELP_WM_HELP, 
                            (DWORD_PTR)(PVOID)aBrowseHelpIDs);
            return TRUE;
        }
        case WM_CONTEXTMENU:
        {
            WinHelp((HWND)wParam,
                            BROWSE_CTX_HELP_FILE,
                            HELP_CONTEXTMENU, 
                            (DWORD_PTR)(PVOID)aBrowseHelpIDs);
            return TRUE; 
        }

        case WM_NOTIFY:
        {
            NMHDR* pnmhdr = (NMHDR*)lParam;
            if (IDC_DOMAIN_TREE != pnmhdr->idFrom || NM_DBLCLK != pnmhdr->code)
                return TRUE;

            TV_ITEM tvi;
            tvi.hItem = TreeView_GetSelection(hTree);
            tvi.mask = TVIF_CHILDREN;
            if ( TreeView_GetItem(hTree, &tvi) == TRUE ) 
            {
                if (tvi.cChildren == 0)
                   PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDOK, (WORD)0), (LPARAM)0);
            }

            return TRUE; 
        }

        case WM_COMMAND:
        {
            switch (LOWORD(wParam)) 
            {
                case IDOK:
                {
                    TV_ITEM tvi;
                    tvi.hItem = TreeView_GetSelection(hTree);
                    tvi.mask = TVIF_PARAM;

                    if ( TreeView_GetItem(hTree, &tvi) == TRUE ) 
                    {
                        DOMAIN_DESC *pDomain = (DOMAIN_DESC *)tvi.lParam;
                        pDialogInfo->pszName = pDomain->pszName;
                        pDialogInfo->pszNCName = pDomain->pszNCName;
                        EndDialog (hwnd, TRUE);
                    }
                    else
                    {
                        pDialogInfo->pszName = NULL;
                        pDialogInfo->pszNCName = NULL;
                        EndDialog (hwnd, FALSE);
                    }

                    return TRUE;        
                }

                case IDCANCEL:
                {
                    pDialogInfo->pszName = NULL;
                    pDialogInfo->pszNCName = NULL;
                    EndDialog (hwnd, FALSE);
                    return TRUE;
                }
            }
        }
    }
  
    return FALSE;
}

//
// exposed API for browsing the tree
//

STDMETHODIMP CDsDomainTreeBrowser::BrowseTo(HWND hwndParent, LPWSTR *ppszTargetPath, DWORD dwFlags)
{
    if (!ppszTargetPath)
        return E_INVALIDARG;

    HRESULT hr;
    PDOMAIN_TREE pDomainTree = NULL;
    DIALOG_STUFF DlgInfo;

    *ppszTargetPath = NULL;         // result is NULL

    hr = GetDomains(&pDomainTree, dwFlags);
    if (SUCCEEDED(hr)) 
    {
        DlgInfo.pDomains = pDomainTree;
        DWORD res = (DWORD)DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_DOMAINBROWSER),
                                                hwndParent, _BrowserDlgProc, (LPARAM)&DlgInfo);

        if (res == IDOK)
        {
          LPWSTR pszPath = DlgInfo.pszName;
          if (dwFlags & DBDTF_RETURNFQDN)
            pszPath = DlgInfo.pszNCName;

          if (pszPath)
          {
            *ppszTargetPath = (LPWSTR)CoTaskMemAlloc(StringByteSizeW(pszPath));
            if (!*ppszTargetPath)
              hr = E_OUTOFMEMORY;
            else
              StrCpyW(*ppszTargetPath, pszPath);

          } else
          {
            hr = S_FALSE;
          }
        }
        else
        {
            hr = S_FALSE;
        }
    }

    FreeDomains(&pDomainTree);
    return hr;
}

//---------------------------------------------------------------------------//

// keep using old values for win9x
// the following comments are for nt when using new api
struct DOMAIN_DATA
{
    WCHAR szName[MAX_PATH]; // domain name (if no dns, use netbios)
    WCHAR szPath[MAX_PATH]; // set to blank
    WCHAR szTrustParent[MAX_PATH]; // parent domain name (if no dns, use netbios)
    WCHAR szNCName[MAX_PATH]; // FQDN: DC=mydomain,DC=microsoft,DC=com
    BOOL fConnected;
    BOOL fRoot; // true if root
    ULONG ulFlags; // type of domain, e.g., external trusted domain
    BOOL fDownLevel; // if NT4 domain
    DOMAIN_DATA * pNext;
};

#define FIX_UP(cast, p, pOriginal, pNew) p ? ((cast)(((LPBYTE)p-(LPBYTE)pOriginal)+(LPBYTE)pNew)):NULL

#define DOMAIN_OBJECT_CLASS L"domainDNS"            // fixed class for domain.

STDMETHODIMP CDsDomainTreeBrowser::GetDomains(PDOMAIN_TREE *ppDomainTree, DWORD dwFlags)
{
    HRESULT hr;
    LPDOMAINTREE pDomainTree = NULL;
    LPDOMAINTREE pSrcDomainTree = NULL;
    LPDOMAINDESC pDomainDesc = NULL;
    DWORD i;

    TraceEnter(TRACE_DOMAIN, "CDsDomainTreeBrowser::GetDomains");

    if ( !ppDomainTree )
        ExitGracefully(hr, E_INVALIDARG, "ppDomainTree == NULL");

    *ppDomainTree = NULL;

    // we support the user giving us a search root (::SetSearchRoot) so if we have
    // one then lets cache in this object the domain tree, otherwise fall back
    // to the global one.

    if ( _pComputerName )
    {
        TraceMsg("We have a computer name, so checking instance cached object");

        if ( !_pDomainTree || _dwFlags != dwFlags)
        {
            TraceMsg("Caching instance domain list");
            if (_pDomainTree)
                FreeDomains(&_pDomainTree); 
            hr = _GetDomains(&_pDomainTree, dwFlags);
            FailGracefully(hr, "Failed to get cached domain list");
            _dwFlags = dwFlags;
        }

        pSrcDomainTree = _pDomainTree;
    }
    else
    {
        TraceMsg("Checking globally cached domain tree (no search root)");

        if ( !g_pDomainTree || g_dwFlags != dwFlags)
        {
            TraceMsg("Caching global domain list");
            if (g_pDomainTree)
                FreeDomains(&g_pDomainTree); 
            hr = _GetDomains(&g_pDomainTree, dwFlags);
            FailGracefully(hr, "Failed to get cached domain list");
            g_dwFlags = dwFlags;
        }

        pSrcDomainTree = g_pDomainTree;
    }

    if ( !pSrcDomainTree )
        ExitGracefully(hr, E_FAIL, "Failed to get cached tree");

    // move and relocate the domain tree, walk all the pointers and offset
    // them from the original to the new.

    TraceMsg("Allocating buffer to copy the domain list");

    pDomainTree = (LPDOMAINTREE)CoTaskMemAlloc(pSrcDomainTree->dsSize);
    TraceAssert(pDomainTree);

    if ( !pDomainTree )
        ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate copy of the domain tree");

    memcpy(pDomainTree, pSrcDomainTree, pSrcDomainTree->dsSize);

    Trace(TEXT("Fixing up %d domains"), pDomainTree->dwCount);

    for ( i = 0 ; i != pDomainTree->dwCount ; i++ )
    {
        pDomainTree->aDomains[i].pszName = FIX_UP(LPWSTR, pDomainTree->aDomains[i].pszName, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pszPath = FIX_UP(LPWSTR, pDomainTree->aDomains[i].pszPath, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pszNCName = FIX_UP(LPWSTR, pDomainTree->aDomains[i].pszNCName, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pszTrustParent = FIX_UP(LPWSTR, pDomainTree->aDomains[i].pszTrustParent, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pszObjectClass = FIX_UP(LPWSTR, pDomainTree->aDomains[i].pszObjectClass, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pdChildList = FIX_UP(LPDOMAINDESC, pDomainTree->aDomains[i].pdChildList, pSrcDomainTree, pDomainTree);
        pDomainTree->aDomains[i].pdNextSibling = FIX_UP(LPDOMAINDESC, pDomainTree->aDomains[i].pdNextSibling, pSrcDomainTree, pDomainTree);
    }

    *ppDomainTree = pDomainTree;
    hr = S_OK;

exit_gracefully:

    if ( FAILED(hr) )
        CoTaskMemFree(pDomainTree);

    TraceLeaveResult(hr);
}

//
// Real _GetDomains that does the work of finding the trusted domains
//

STDMETHODIMP CDsDomainTreeBrowser::_GetDomains(PDOMAIN_TREE *ppDomainTree, DWORD dwFlags)
{
    HRESULT hr = S_OK;
    UINT cbSize = 0;
    UINT cDomains = 0, cRootDomains =0, cbStringStorage = 0;
    struct DOMAIN_DATA * pCurrentDomain = NULL;
    struct DOMAIN_DATA * pFirstDomain = NULL;
    DOMAIN_DESC * pDestDomain = NULL;
    DOMAIN_DESC * pDestRootDomain = NULL;
    LPWSTR pNextFree;
    UINT index, index_inner;
    DOMAIN_DESC * pPotentialChild, * pPotentialParent;
    USES_CONVERSION;
    ULONG ulParentIndex = 0;
    ULONG ulCurrentIndex = 0;
    ULONG ulEntryCount = 0;
    PDS_DOMAIN_TRUSTS pDomainList = NULL;
    PDS_DOMAIN_TRUSTS pDomain = NULL;
    NET_API_STATUS NetStatus = NO_ERROR;
    ULONG ulFlags = DS_DOMAIN_PRIMARY | DS_DOMAIN_IN_FOREST;
    BOOL bDownLevelTrust = FALSE;
    BOOL bUpLevelTrust = FALSE;
    BOOL bExternalTrust = FALSE;

    TraceEnter(TRACE_DOMAIN, "CDsDomainTreeBrowser::_GetDomains");
    *ppDomainTree = NULL;

    if (dwFlags & DBDTF_RETURNINOUTBOUND)
    {
        ulFlags |= (DS_DOMAIN_DIRECT_INBOUND | DS_DOMAIN_DIRECT_OUTBOUND);
    }
    else if (dwFlags & DBDTF_RETURNINBOUND)
    { 
        ulFlags |= DS_DOMAIN_DIRECT_INBOUND;
    }
    else
    {
        ulFlags |= DS_DOMAIN_DIRECT_OUTBOUND;
    }

    // wack off the port number if we have server:<n> specified

    LPWSTR pszPort = NULL;
    if (NULL != _pComputerName)
    {
        pszPort = StrChrW(_pComputerName, L':');
        if ( pszPort )
            *pszPort = L'\0';
    }

    // get the domain list

    NetStatus = DsEnumerateDomainTrusts(
                _pComputerName,
                ulFlags,
                &pDomainList,
                &ulEntryCount );
    if (ERROR_ACCESS_DENIED == NetStatus &&
        _pComputerName && *_pComputerName &&
        _pUserName && *_pUserName)
    {
        //
        // make the connection, try one more time
        //
        WCHAR wszIPC[MAX_PATH];
        if (L'\\' == *_pComputerName)
        {
          StrCpyW(wszIPC, _pComputerName);
        }
        else 
        {
          StrCpyW(wszIPC, L"\\\\");
          StrCatW(wszIPC, _pComputerName);
        }
        StrCatW(wszIPC, L"\\IPC$");
    
        NETRESOURCEW nr = {0};
        nr.dwType = RESOURCETYPE_ANY;
        nr.lpLocalName = NULL;
        nr.lpRemoteName = wszIPC;
        nr.lpProvider = NULL;

        DWORD dwErr = WNetAddConnection2W(&nr, _pPassword, _pUserName, 0);
        if (NO_ERROR == dwErr || ERROR_SESSION_CREDENTIAL_CONFLICT == dwErr)
        {
            NetStatus = DsEnumerateDomainTrusts(
                        _pComputerName,
                        ulFlags,
                        &pDomainList,
                        &ulEntryCount );
        } else
        {
            NetStatus = dwErr;
        }

        //
        // soft close the connection opened by us
        //
        if (NO_ERROR == dwErr)
        {
            (void) WNetCancelConnection2W(wszIPC, 0, FALSE);
        }
    }

    // restore the port seperator

    if ( pszPort )
        *pszPort = L':';

    if ( NetStatus != NO_ERROR )
       ExitGracefully(hr, HRESULT_FROM_WIN32(NetStatus), "Failed to enum trusted domains");

    for (ulCurrentIndex=0; ulCurrentIndex<ulEntryCount; ulCurrentIndex++ )
    {
        pDomain = &(pDomainList[ulCurrentIndex]);

        bDownLevelTrust = pDomain->TrustType & TRUST_TYPE_DOWNLEVEL;
        bUpLevelTrust = pDomain->TrustType & TRUST_TYPE_UPLEVEL; // trust between 2 NT5 domains

        //
        // we don't consider other type of trusts, e.g, MIT
        //
        if (!bDownLevelTrust && !bUpLevelTrust)
            continue;

        //
        // skip if caller has no interest in downlevel trust
        //
        if ( !(dwFlags & DBDTF_RETURNMIXEDDOMAINS) && bDownLevelTrust)
            continue;

        bExternalTrust = !(pDomain->Flags & DS_DOMAIN_IN_FOREST);

        //
        // skip if caller has no interest in external trust
        //
        if ( !(dwFlags & DBDTF_RETURNEXTERNAL) && bExternalTrust)
            continue;

        cDomains++;

        if (pFirstDomain == NULL)
        {
            pCurrentDomain = new DOMAIN_DATA;
            TraceAssert(pCurrentDomain);

            if ( !pCurrentDomain )
                ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate DOMAIN_DATA structure");

            ZeroMemory(pCurrentDomain, sizeof(DOMAIN_DATA));
            pFirstDomain = pCurrentDomain;
        }
        else
        {
            pCurrentDomain->pNext = new DOMAIN_DATA;
            TraceAssert(pCurrentDomain->pNext);

            if ( !pCurrentDomain->pNext )
                ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate DOMAIN_DATA structure (not first item)");

            pCurrentDomain = pCurrentDomain->pNext;
            ZeroMemory(pCurrentDomain, sizeof(DOMAIN_DATA));
        }

        // fill the structure with data from the queried object.

        pCurrentDomain->pNext = NULL;
        pCurrentDomain->ulFlags = pDomain->Flags;
        pCurrentDomain->szPath[0] = L'\0';
        pCurrentDomain->fDownLevel = bDownLevelTrust;

        if (pDomain->DnsDomainName)
        {
            StrCpyW(pCurrentDomain->szName,
            pDomain->DnsDomainName);

            // remove the last dot
            int   i = 0;
            PWSTR p = NULL;
            int nLength = lstrlenW(pCurrentDomain->szName);

            if ( L'.' == pCurrentDomain->szName[nLength-1] )
            {
                pCurrentDomain->szName[nLength-1] = L'\0';
                nLength--;
            }

            if (dwFlags & DBDTF_RETURNFQDN)
            {
                // if switch to DsCrackName in the future,
                // 1. append trailing '/' to the dns domain name
                // 2. use DS_NAME_NO_FLAGS as flags
                // 3. use DS_CANONICAL_NAME as formatOffered
                // 4. use DS_FQDN_1779_NAME as formatDesired
                // what is hDS???

                StrCpyW(pCurrentDomain->szNCName, L"DC=");
                p = pCurrentDomain->szNCName + 3;
                for (i=0; i<nLength; i++)
                {
                    if ( L'.' == pCurrentDomain->szName[i] )
                    {
                        StrCpyW(p, L",DC=");
                        p += 4;
                    } 
                    else
                    {
                        *p = pCurrentDomain->szName[i];
                        p++;
                    }
                }
            } 
            else
            {
                pCurrentDomain->szNCName[0] = L'\0';
            }
        } 
        else
        {
            StrCpyW(pCurrentDomain->szName,
            pDomain->NetbiosDomainName);

            pCurrentDomain->szNCName[0] = L'\0'; // downlevel domain has no FQDN
        }

        // treat external trusted domain as root domain
        pCurrentDomain->fRoot = 
            ( ( !bExternalTrust && (pDomain->Flags & DS_DOMAIN_TREE_ROOT) ) ||
              bExternalTrust );

        if ( pCurrentDomain->fRoot )
        {
            cRootDomains++;
        } else {
            ulParentIndex = pDomain->ParentIndex;

            if (pDomainList[ulParentIndex].DnsDomainName)
                StrCpyW(pCurrentDomain->szTrustParent, pDomainList[ulParentIndex].DnsDomainName);
            else
                StrCpyW(pCurrentDomain->szTrustParent, pDomainList[ulParentIndex].NetbiosDomainName);
        }

        cbStringStorage += StringByteSizeW(pCurrentDomain->szName);
        cbStringStorage += StringByteSizeW(pCurrentDomain->szPath);
        cbStringStorage += StringByteSizeW(pCurrentDomain->szTrustParent);
        cbStringStorage += StringByteSizeW(pCurrentDomain->szNCName);
// hard-coded domainDNS should get from object
        cbStringStorage += StringByteSizeW(DOMAIN_OBJECT_CLASS);
    }

    Trace(TEXT("cDomains %d, cRootDomains %d"), cDomains, cRootDomains);

    if ( cRootDomains == 0 )
        ExitGracefully(hr, HRESULT_FROM_WIN32(ERROR_CANT_ACCESS_DOMAIN_INFO), "No root domains, so failing _GetDomains call");

    TraceMsg("Building structure information");

// REVIEW_MARCOC: we allocate more memory than strictly necessary...
    cbSize = sizeof(DOMAIN_TREE) + (cDomains * sizeof(DOMAIN_DESC)) + cbStringStorage;
    *ppDomainTree  = (PDOMAIN_TREE)CoTaskMemAlloc(cbSize);
    TraceAssert(*ppDomainTree);

    if ( !*ppDomainTree )
        ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate DOMAINDTREE structure");

    memset(*ppDomainTree, 0, cbSize);
    pNextFree = (LPWSTR)ByteOffset((*ppDomainTree), sizeof(DOMAIN_TREE) + (cDomains * sizeof(DOMAIN_DESC)) );

    // loop to copy the nodes, roots first
    pDestRootDomain = &((*ppDomainTree)->aDomains[0]);
    pDestDomain = &((*ppDomainTree)->aDomains[cRootDomains]);

    for ( pCurrentDomain = pFirstDomain; pCurrentDomain; pCurrentDomain = pCurrentDomain->pNext )
    {
        if (pCurrentDomain->fRoot)
        {
            Trace(TEXT("Object is a domain root: %s"), pCurrentDomain->szName);

            pDestRootDomain->pszName = pNextFree;
            StrCpyW(pDestRootDomain->pszName, pCurrentDomain->szName);
            pNextFree += lstrlenW(pCurrentDomain->szName) + 1;

            pDestRootDomain->pszPath = pNextFree;
            StrCpyW(pDestRootDomain->pszPath, pCurrentDomain->szPath);
            pNextFree += lstrlenW(pCurrentDomain->szPath) + 1;

            pDestRootDomain->pszNCName = pNextFree;
            StrCpyW(pDestRootDomain->pszNCName, pCurrentDomain->szNCName);
            pNextFree += lstrlenW(pCurrentDomain->szNCName) + 1;

            pDestRootDomain->pszTrustParent = NULL;

// hard-coded domainDNS should get from object
            pDestRootDomain->pszObjectClass = pNextFree;
            StrCpyW(pDestRootDomain->pszObjectClass, DOMAIN_OBJECT_CLASS);
            pNextFree += lstrlenW(DOMAIN_OBJECT_CLASS) + 1;

            pDestRootDomain->ulFlags = pCurrentDomain->ulFlags;
            pDestRootDomain->fDownLevel = pCurrentDomain->fDownLevel;

            pDestRootDomain->pdNextSibling = NULL;

            if (pDestRootDomain > &((*ppDomainTree)->aDomains[0]))
            {
                (&(pDestRootDomain[-1]))->pdNextSibling = pDestRootDomain;
            }

            pDestRootDomain++;
        }
        else
        {
            Trace(TEXT("Object is not a domain root: %s"), pCurrentDomain->szName);

            pDestDomain->pszName = pNextFree;
            StrCpyW(pDestDomain->pszName, pCurrentDomain->szName);
            pNextFree += lstrlenW(pDestDomain->pszName) + 1;

            pDestDomain->pszPath = pNextFree;
            StrCpyW(pDestDomain->pszPath, pCurrentDomain->szPath);
            pNextFree += lstrlenW(pDestDomain->pszPath) + 1;

            pDestDomain->pszNCName = pNextFree;
            StrCpyW(pDestDomain->pszNCName, pCurrentDomain->szNCName);
            pNextFree += lstrlenW(pDestDomain->pszNCName) + 1;

            pDestDomain->pszTrustParent = pNextFree;
            StrCpyW(pDestDomain->pszTrustParent, pCurrentDomain->szTrustParent);
            pNextFree += lstrlenW(pDestDomain->pszTrustParent) + 1;

// hard-coded domainDNS should get from object
            pDestDomain->pszObjectClass = pNextFree;
            StrCpyW(pDestDomain->pszObjectClass, DOMAIN_OBJECT_CLASS);
            pNextFree += lstrlenW(DOMAIN_OBJECT_CLASS) + 1;

            pDestDomain->ulFlags = pCurrentDomain->ulFlags;
            pDestDomain->fDownLevel = pCurrentDomain->fDownLevel;

            pDestDomain++;
        }

    }

    TraceMsg("Finished first pass creating domain structure, now building per level items");

    // walk list, picking up each item per level, until all items
    // have been placed in structure.
    // return structure.

    for (index = 0; index < cDomains; index ++)
    {
        pPotentialParent = &((*ppDomainTree)->aDomains[index]);
        Trace(TEXT("pPotentialParent %08x, index %d"), pPotentialParent, index);

        for (index_inner = 0; index_inner < cDomains; index_inner++)
        {
            pPotentialChild = &((*ppDomainTree)->aDomains[index_inner]);
            Trace(TEXT("pPotentialChild %08x, index_inner %d"), pPotentialChild, index_inner);

            if (pPotentialChild == pPotentialParent)
            {
                TraceMsg("parent == child, skipping");
                continue;
            }

            Trace(TEXT("Comparing %s to %s"),
                            pPotentialChild->pszTrustParent ? W2T(pPotentialChild->pszTrustParent):TEXT("NULL"),
                                W2T(pPotentialParent->pszPath));

            if ((pPotentialChild->pszTrustParent != NULL) &&
                   (!StrCmpW(pPotentialChild->pszTrustParent, pPotentialParent->pszName)))
            {
                TraceMsg("Child found, scanning for end of child list");

                // this is a child. figure out where end of child chain is
                if (pPotentialParent->pdChildList == NULL)
                {
                    TraceMsg("Parent has no children, this becomes the child");
                    pPotentialParent->pdChildList = pPotentialChild;
                }
                else
                {
                    DOMAIN_DESC * pdScan = pPotentialParent->pdChildList;		
                    Trace(TEXT("Scanning from %08x"), pdScan);			

                    while (pdScan->pdNextSibling != NULL)
                    {
                        pdScan = pdScan->pdNextSibling;
                        Trace(TEXT("Advancing to %08x"), pdScan);
                    }

                    Trace(TEXT("Setting next sibling on %08x"), pdScan);
                    pdScan->pdNextSibling = pPotentialChild;
                }
            }
        }
    }

    TraceMsg("Finished fix up, setting cbSize + domains");

    (*ppDomainTree)->dwCount = cDomains;
    (*ppDomainTree)->dsSize = cbSize;

    hr = S_OK;                  // success

exit_gracefully:

    if (pDomainList)
      NetApiBufferFree(pDomainList);

    if (pFirstDomain != NULL)
    {
        TraceMsg("pFirstDomain != NULL");

        while (pFirstDomain != NULL)
        {
            Trace(TEXT("Releasing domain %08x"), pFirstDomain);
            pCurrentDomain = pFirstDomain;
            pFirstDomain = pFirstDomain->pNext;
            delete pCurrentDomain;
        }
    }

    if ( FAILED(hr) )
    {
        TraceMsg("Freeing the domain tree structure because we failed");
        FreeDomains(ppDomainTree);
    }

    TraceLeaveResult(hr);
}

//---------------------------------------------------------------------------//

STDMETHODIMP CDsDomainTreeBrowser::FreeDomains(PDOMAIN_TREE* ppDomainTree)
{
    HRESULT hr;

    TraceEnter(TRACE_DOMAIN, "CDsDomainTreeBrowser::FreeDomains");

    if ( !ppDomainTree )
        ExitGracefully(hr, E_INVALIDARG, "No pDomainTree");

    if ( *ppDomainTree )
    {
        CoTaskMemFree(*ppDomainTree);
        *ppDomainTree = NULL;
    }

    hr = S_OK;

exit_gracefully:

    TraceLeaveResult(hr);
}

//---------------------------------------------------------------------------//

STDMETHODIMP CDsDomainTreeBrowser::FlushCachedDomains()
{
    HRESULT hr;

    TraceEnter(TRACE_DOMAIN, "CDsDomainTreeBrowser::FlushCachedDomains");

    hr = FreeDomains(&g_pDomainTree);
    FailGracefully(hr, "Failed to free cached domain list");

    hr = FreeDomains(&_pDomainTree);
    FailGracefully(hr, "Failed to free cached domain list (for search root)");

    hr = S_OK;              // success

exit_gracefully:

    TraceLeaveResult(hr);
}