windows-server-2003/base/fs/remotefs/dfs/tools/dfsutil/dfsutil.cxx

//--------------------------------------------------------------------------
//
//  Copyright (C) 1999, Microsoft Corporation
//
//  File:       dfsutil.cxx
//
//--------------------------------------------------------------------------

extern "C" {
#include <stdio.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <shellapi.h>
#include <winldap.h>
#include <stdlib.h>
}
#include <lm.h>
#include <lmdfs.h>
#include <dfsfsctl.h>
#include <dsgetdc.h>
#include <ole2.h>
#include <activeds.h>
#include <dfsprefix.h>
#include <DfsServerLibrary.hxx>
#include <dfsmisc.h>
#include "dsgetdc.h"
#include "dsrole.h"

#include "dfsutil.hxx"
#include "dfspathname.hxx"

#include "struct.hxx"
#include "flush.hxx"
#include "misc.hxx"
#include "info.hxx"
#include "messages.h"
#include "dfsreparse.hxx"

#include "dfswmi.h"

#include "dfsroot.hxx"
#define WPP_BIT_CLI_DRV 0x01

#define WPP_LEVEL_FLAGS_LOGGER(lvl,flags) WPP_LEVEL_LOGGER(flags)
#define WPP_LEVEL_FLAGS_ENABLED(lvl, flags) (WPP_LEVEL_ENABLED(flags) && WPP_CONTROL(WPP_BIT_CLI_DRV ).Level >= lvl)
  

#define WPP_LEVEL_ERROR_FLAGS_LOGGER(lvl, error, flags) WPP_LEVEL_LOGGER(flags)
#define WPP_LEVEL_ERROR_FLAGS_ENABLED(lvl, error, flags) \
  ((!NT_SUCCESS(error) || WPP_LEVEL_ENABLED(flags)) && WPP_CONTROL(WPP_BIT_CLI_DRV ).Level >= lvl)

#include "dfsutil.tmh"


UNICODE_STRING DCToUseFlatDomainName;
UNICODE_STRING DCToUseDNSDomainName;
LPWSTR DCToUse = NULL;
DFSSTATUS DCInfoStatus = ERROR_SUCCESS;

extern
void 
SetReferralControl(WPP_CB_TYPE * Control);

DFSSTATUS
ProcessRootForSite(
    DfsRoot *pRoot );

DFSSTATUS
PurgeSiteInformationForRoot(
    DfsRoot *pRoot );

DFSSTATUS
DumpSiteBlob(
    PVOID pBuffer,
    ULONG Size,
    BOOLEAN Display );

//
// How we make args & switches
//

#define MAKEARG(x) \
    WCHAR Arg##x[] = L"/" L#x L":"; \
    LONG ArgLen##x = (sizeof(Arg##x) / sizeof(WCHAR)) - 1; \
    BOOLEAN fArg##x;

#define SWITCH(x) \
    WCHAR Sw##x[] = L"/" L#x ; \
    BOOLEAN fSw##x;

#define FMAKEARG(x) \
    static WCHAR Arg##x[] = L#x L":"; \
    static LONG ArgLen##x = (sizeof(Arg##x) / sizeof(WCHAR)) - 1; \
    static BOOLEAN fArg##x;

#define FSWITCH(x) \
    static WCHAR Sw##x[] = L"/" L#x ; \
    static BOOLEAN fSw##x;

DFSSTATUS
DfsReadFromAD( 
    LPWSTR DomainName,
    LPWSTR Name,
    LPWSTR FileName,
    LPWSTR UseDC );

DFSSTATUS
DfsReadFromFile(
    LPWSTR Name );



LPWSTR pwszServerName = NULL;
LPWSTR pwszDomainName = NULL;
LPWSTR pwszEntryToFlush = NULL;
LPWSTR pwszComment = NULL;
LPWSTR pwszShareName = NULL;
LPWSTR pwszLogicalName = NULL;
LPWSTR pwszHexValue = NULL;
LPWSTR ImportFile = NULL;

DfsPathName OperateNameSpace;
DfsPathName MasterNameSpace;
DfsPathName OldDomainName;
DfsPathName NewDomainName;

DfsString ClientForSiteName;

LPWSTR ExportBlobFile = NULL;
LPWSTR DisplayBlobFile = NULL;

BOOLEAN CmdRequiresDirect = FALSE;
LPWSTR ExportFile = NULL;
LPWSTR DebugFile = NULL;
LPWSTR BackupFile = NULL;
LPWSTR pwszVolumeName = NULL;
LPWSTR pwszDfsDirectoryName = NULL;
LPWSTR pwszDcName = NULL;

DFS_API_MODE Mode = MODE_EITHER;
    
DFSSTATUS DirectModeFailStatus = ERROR_SUCCESS;


HANDLE ShowHandle= INVALID_HANDLE_VALUE;
HANDLE DebugHandle= INVALID_HANDLE_VALUE;
HANDLE ExportHandle= INVALID_HANDLE_VALUE;
HANDLE BackupHandle = INVALID_HANDLE_VALUE;


MAKEARG(RemFtRoot);
SWITCH(RemFtRoot);

MAKEARG(Domain);
MAKEARG(Server);
MAKEARG(Share);

SWITCH(DisplayBlob);
MAKEARG(DisplayBlob);


MAKEARG(Import);
SWITCH(Import);     // The switch is just a cue for Help here.
MAKEARG(Export);
MAKEARG(Backup);
SWITCH(NoBackup);
SWITCH(Export);
MAKEARG(Root);
SWITCH(Root);
MAKEARG(DebugFile);
MAKEARG(OldDomain);
MAKEARG(NewDomain);
SWITCH(UnmapFtRoot);
SWITCH(Unmap);
MAKEARG(UnmapFtRoot);

MAKEARG(SiteName);
SWITCH(SiteName);
MAKEARG(Clean);
SWITCH(Clean);
SWITCH(Insite);
SWITCH(SiteCosting);
SWITCH(RootScalability);

SWITCH(ViewDfsDirs);
MAKEARG(ViewDfsDirs);

//MAKEARG(RemoveReparse);
MAKEARG(DebugDC);
SWITCH(RemoveReparse);
SWITCH(DC);

SWITCH(ExportBlob);
MAKEARG(ExportBlob);

MAKEARG(ImportRoot);
SWITCH(ImportRoot);

SWITCH(PurgeMupCache);
SWITCH(UpdateWin2kStaticSiteTable);
SWITCH(ShowWin2kStaticSiteTable);
SWITCH(PurgeWin2kStaticSiteTable);

SWITCH(CheckBlob);
SWITCH(BlobSize);



//
// Switches (ie '/arg')
//

SWITCH(AddStdRoot);
SWITCH(AddFtRoot);
SWITCH(Debug);
SWITCH(Verbose);
SWITCH(Help);
SWITCH(ScriptHelp);
SWITCH(PktInfo);
SWITCH(Dfs);
SWITCH(All);
SWITCH(Set);
SWITCH(Mirror);
SWITCH(RemStdRoot);
SWITCH(Api);

SWITCH(Compare);
SWITCH(Merge);
SWITCH(Direct);
SWITCH(RenameFtRoot);
SWITCH(View);
SWITCH(Disable);
SWITCH(Enable);
SWITCH(Display);



//
// Either a switch or an arg
//
MAKEARG(PktFlush);
SWITCH(PktFlush);
MAKEARG(SpcFlush);
SWITCH(SpcFlush);
MAKEARG(SpcInfo);
SWITCH(SpcInfo);
MAKEARG(Level);


//
// The macro can not make these
//

WCHAR SwQ[] = L"/?";
BOOLEAN fSwQ;

ULONG AddLinks, RemoveLinks, AddTargets, RemoveTargets, ErrorLinks,
       DirectMode, ApiCalls, SetInfoState, SetInfoComment;
ULONG TotalNamespaceCost;

BOOLEAN CommandSucceeded = FALSE;
BOOLEAN ErrorDisplayed = FALSE;
static BOOLEAN LastOptionWasInsite = FALSE;
static BOOLEAN DirectModeOnly = FALSE;
static BOOLEAN UserRequiresDirectMode = FALSE;

DFSSTATUS
CmdInitializeDirectMode(
    PBOOLEAN pCoInitialized);
    
DWORD
Usage();

DWORD
CmdProcessUserCreds(
    VOID);

BOOLEAN
CmdProcessArg(
    LPWSTR Arg);


DFSSTATUS
CmdCheckSyntax( BOOLEAN& Done );

DFSSTATUS
IsRootStandalone( 
    DfsPathName *PathComps,
    PBOOLEAN pIsAdBlob );

DWORD
IsThisADomainName(
    IN LPWSTR wszName,
    OUT PWCHAR *ppList OPTIONAL);

DFSSTATUS
CmdCheckExceptions( DfsPathName *Namespace );

extern DFSSTATUS
DfsExtendedWin2kRootAttributes(
    DfsPathName *Namespace,
    PULONG pAttr,
    BOOLEAN Set);


DFSSTATUS
GetDCInformation()
{
    PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pPrimaryDomainInfo = NULL;
    DFSSTATUS Status = ERROR_SUCCESS;

    Status = DsRoleGetPrimaryDomainInformation( DCToUse,
                                                DsRolePrimaryDomainInfoBasic,
                                                (PBYTE *)&pPrimaryDomainInfo);
    if (Status != ERROR_SUCCESS)
    {
        DCInfoStatus = Status;
        return ERROR_SUCCESS;
    }

    if (Status == ERROR_SUCCESS)
    {
        UNICODE_STRING DomainNameFlat;
        Status = DfsRtlInitUnicodeStringEx( &DomainNameFlat, 
                                            pPrimaryDomainInfo->DomainNameFlat);
        if(Status == ERROR_SUCCESS)
        {
            Status = DfsCreateUnicodeString( &DCToUseFlatDomainName,
                                             &DomainNameFlat );

        }

        if (Status == ERROR_SUCCESS)
        {
            UNICODE_STRING DomainNameDNS;
            Status = DfsRtlInitUnicodeStringEx( &DomainNameDNS, 
                                            pPrimaryDomainInfo->DomainNameDns);
            if(Status == ERROR_SUCCESS)
            {
                Status = DfsCreateUnicodeString( &DCToUseDNSDomainName,
                                                 &DomainNameDNS );

            }
        }

        DsRoleFreeMemory(pPrimaryDomainInfo);
    }

    return Status;
}


DFSSTATUS
DfsEnumerateDomainDfs(
    LPWSTR Domain)
{
    DFSSTATUS Status;
    PDFS_INFO_200  pBuffer = NULL, pCurBuffer;
    DWORD   dwEntriesRead = 0;
    DWORD   dwResumeHandle = 0;
    DWORD   dwTotalEntries = 0;

    do {

        dwEntriesRead = 0;

        Status = NetDfsEnum( Domain,
                             200,
                             (DWORD)-1,
                             (LPBYTE *)&pBuffer,
                             &dwEntriesRead,
                             &dwResumeHandle );
    
        if (Status == ERROR_SUCCESS) 
        {
            pCurBuffer = pBuffer;
    
            if (dwEntriesRead) 
            {
                if (dwTotalEntries == 0) {
                    ShowInformation((L"\nRoots on Domain %ws\n\n", Domain));
                }
                for (DWORD i=0; i<dwEntriesRead; i++)
                {
                    ShowInformation((L"\t%ws\n", pCurBuffer[i].FtDfsName));
                    dwTotalEntries++;
                }
            }
        }
        if (NULL != pBuffer)
        {
                NetApiBufferFree(pBuffer);
                pBuffer = NULL;
        }
    } while ( Status == ERROR_SUCCESS && dwResumeHandle != NULL );

    if (dwTotalEntries > 0)
    {
        ShowInformation((L"\nDone with Roots on Domain %ws\n", Domain));

        if (Status == ERROR_NO_MORE_ITEMS) {
            Status = ERROR_SUCCESS;
        }
    }
    else
    {
        ShowInformation((L"\n\nNo roots exist on domain %ws\n\n", Domain));
    }

    return Status;
}

DFSSTATUS
DfsEnumerateMachineDfs(
    LPWSTR Server)
{
    DFSSTATUS Status;
    PDFS_INFO_300  pBuffer = NULL, pCurBuffer;
    DWORD   dwEntriesRead = 0;
    DWORD   dwResumeHandle = 0;
    DWORD   dwTotalEntries = 0;

    do {

        dwEntriesRead = 0;

        Status = NetDfsEnum( Server,
                             300,
                             (DWORD)-1,
                             (LPBYTE *)&pBuffer,
                             &dwEntriesRead,
                             &dwResumeHandle );
    
        if (Status == ERROR_SUCCESS) 
        {
            pCurBuffer = pBuffer;
            if (dwEntriesRead) 
            {
                if (dwTotalEntries == 0) {
                    ShowInformation((L"\nRoots on machine %ws\n\n", Server));
                }
                for (DWORD i=0; i<dwEntriesRead; i++)
                {
                    ShowInformation((L"\t%ws\n", pCurBuffer[i].DfsName));
                    dwTotalEntries++;
                }
            }
        }
        if (NULL != pBuffer)
        {
                NetApiBufferFree(pBuffer);
                pBuffer = NULL;
        }

    } while ( Status == ERROR_SUCCESS && dwResumeHandle != NULL );

    if (dwTotalEntries > 0)
    {
        ShowInformation((L"\nDone with Roots on machine %ws\n", Server));

        if (Status == ERROR_NO_MORE_ITEMS) {
            Status = ERROR_SUCCESS;
        }
    }
    else
    {
        ShowInformation((L"\n\nNo roots exist on machine %ws\n\n", Server));
    }

    return Status;
}
_cdecl
main(int argc, char *argv[])
{
    UNREFERENCED_PARAMETER(argv);
    UNREFERENCED_PARAMETER(argc);
    DWORD dwErr = ERROR_SUCCESS;
    LPWSTR CommandLine;
    LPWSTR *argvw;
    int argx;
    int argcw;
    BOOLEAN CoInitialized = FALSE;  
    BOOLEAN DirectModeInitialized = FALSE;
    BOOLEAN Done;
    
    WPP_CB_TYPE *pLogger = NULL;

    pLogger = &WPP_CB[WPP_CTRL_NO(WPP_BIT_CLI_DRV)];

    WPP_INIT_TRACING(L"DfsUtil");
    SetReferralControl(pLogger);

    ShowHandle = GetStdHandle(STD_OUTPUT_HANDLE);
    DebugHandle = GetStdHandle(STD_OUTPUT_HANDLE);
    //
    // Do the work
    //
    do {
        ErrorMessage( MSG_COPYRIGHT );
    
        if ((dwErr = DfsPrefixTableInit()) != STATUS_SUCCESS)
        {
            break;
        }
        
        //
        // Get the command line in Unicode
        //

        CommandLine = GetCommandLine();

        argvw = CommandLineToArgvW(CommandLine, &argcw);

        if ( argvw == NULL ) {
            DebugInformation((L"DfsUtil:Can't convert command line to Unicode: %d\r\n", GetLastError()));
            dwErr = GetLastError();
            break;
        }

        //
        // Get the arguments
        //
        if (argcw <= 1) {
            dwErr = Usage();
            break;
        }

        
        //
        // Process arguments. Direct mode is enabled by default.
        //
        fSwDirect = TRUE;
        UserRequiresDirectMode = FALSE;
        Done = FALSE;
        
        for (argx = 1; argx < argcw && !Done; argx++) {
            Done = CmdProcessArg(argvw[argx]);
        }
        if (Done) {
            Usage();
            break;
        }

        //
        // Some sanity checking of cmd syntax.
        // This also prints all appropriate error help messages.
        //
        dwErr = CmdCheckSyntax( Done );
        if (Done) {
            break;
        }
        
        if (fSwPktFlush == TRUE || fArgPktFlush == TRUE) {
            dwErr = PktFlush(pwszEntryToFlush);
            break;
        } else if (fSwSpcFlush == TRUE || fArgSpcFlush == TRUE) {
            dwErr = SpcFlush(pwszEntryToFlush);
            break;
        } else if (fSwPktInfo == TRUE) {
            dwErr = PktInfo(fSwDfs, pwszHexValue);
            break;
        } else if (fSwSpcInfo == TRUE) {
            dwErr = SpcInfo(fSwAll);
            break;
        }

        if(fArgViewDfsDirs)
        {
            BOOL fRemove = FALSE;

            if(fSwRemoveReparse)
            {
               fRemove =TRUE;
            }

            dwErr = CountReparsePoints(pwszVolumeName, fRemove);
            break;
        }
/*
        BUG 736596: DeleteReparsePoint as implemented doesn't walk through
        all subdirectories of a given directory. In fact, it doesn't seem to work
        at all. We should probably address this in the longhorn timeframe.
        
        if(fArgRemoveReparse)
        {
            dwErr = DeleteReparsePoint(pwszDfsDirectoryName);
            break;
        }
*/
        if (fSwAddStdRoot == TRUE) {
            dwErr = CmdAddRoot(
                        FALSE,
                        pwszServerName,
                        pwszShareName,
                        pwszShareName, // Enforce RootName = Sharename
                        pwszComment);
            break;
        }

        if (fSwAddFtRoot == TRUE) {
            dwErr = CmdAddRoot(
                        TRUE,
                        pwszServerName,
                        pwszShareName,
                        pwszShareName, // Enforce RootName = Sharename
                        pwszComment);
            break;
        } 

        if (fSwRemStdRoot == TRUE) {
            dwErr = CmdRemRoot(
                        FALSE,
                        pwszServerName,
                        pwszShareName,
                        pwszShareName); // Sharename = logicalname.
            break;
        } 

        //
        // We allow users to delete roots whose logical name don't match
        // their physical share names for compatibility reasons.
        // DfsUtil itself doesn't allow people to create such roots however.
        //
        if (fArgRemFtRoot == TRUE || fSwRemFtRoot == TRUE) {
            dwErr = CmdRemRoot(
                        TRUE,
                        pwszServerName,
                        pwszShareName,
                        pwszLogicalName); // logical name may differ.
            break;
        } 


        if (fSwClean) {
            dwErr = CmdClean( pwszServerName, pwszShareName );
            break;
        }

        if ((Mode == MODE_DIRECT) || (Mode == MODE_EITHER))
        {
            dwErr = CmdInitializeDirectMode( &CoInitialized);

            if (dwErr != ERROR_SUCCESS)
            {
                DirectModeFailStatus = dwErr;
                if (Mode == MODE_DIRECT)
                {
                    DebugInformation((L"DfsUtil: Failed direct communication with DFS metadata, status 0x%x\n", dwErr));
                    ErrorMessage(MSG_ROOT_DIRECT_FAILED, dwErr);
                    break;
                }
                else if (CmdRequiresDirect == TRUE)
                {
                    ErrorMessage(MSG_ROOT_DIRECT_REQUIRED_FAILED, dwErr);
                    break;
                }
                else
                {
                    Mode = MODE_API;
                }
            }
            else
            {
                    DirectModeInitialized = TRUE;
            }
        }

        if (CmdRequiresDirect && (DirectModeInitialized == FALSE)) 
        {
            ErrorMessage(MSG_ROOT_DIRECT_REQUIRED);
            break;
        }

        if (fSwUpdateWin2kStaticSiteTable)
        {
            DfsRoot *pOperateRoot = NULL;
            dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                  DCToUse,
                                                  Mode,
                                                  TRUE, // site aware
                                                  &pOperateRoot);
            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = ProcessRootForSite(pOperateRoot );
            }

            if(pOperateRoot)
            {
                pOperateRoot->Close();
            }
            break;
        }


        if (fSwPurgeWin2kStaticSiteTable)
        {
            DfsRoot *pOperateRoot = NULL;
            dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                  DCToUse,
                                                  Mode,
                                                  FALSE,
                                                  &pOperateRoot);
            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = PurgeSiteInformationForRoot(pOperateRoot );
            }

            if(pOperateRoot)
            {
                pOperateRoot->Close();
            }
            break;
        }
        
        if (fSwShowWin2kStaticSiteTable)

        {
            DfsRoot *pOperateRoot = NULL;
            PVOID pBuffer = NULL;
            ULONG Size = 0;

            dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                  DCToUse,
                                                  Mode,
                                                  FALSE,
                                                  &pOperateRoot);

            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = pOperateRoot->RootGetSiteBlob(&pBuffer, &Size);
            }

            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = DumpSiteBlob((PVOID)pBuffer, Size, TRUE);
            }
            if(pOperateRoot)
            {
                pOperateRoot->Close();
            }
            break;
        }

        //
        // Importing a namespace from a script file.
        //
        if (fArgImport) {

            DfsRoot *pMasterRoot;
            DfsRoot *pOperateRoot;

            dwErr = DfsReadDocument( ImportFile,
                                     &pMasterRoot );

            if (dwErr == ERROR_SUCCESS)
            {
                if (fSwBlobSize)
                {
                    ULONG RootBlobSize = 0;

                    extern DFSSTATUS SizeRoot(DfsRoot *pRoot, PULONG pSize);

                    dwErr = SizeRoot(pMasterRoot, &RootBlobSize);
                    if (dwErr == ERROR_SUCCESS)
                    {
                        ShowInformation((L"\n\nApproximate blob size for import file is %.2f Megabytes\n\n",
                                         (DOUBLE)RootBlobSize / (1024 * 1024)));

                    }
                }
                else if (fSwView)
                {
                    DumpRoots(pMasterRoot, ShowHandle, FALSE);
                }
                else 
                {
                    dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                          DCToUse,
                                                          Mode,
                                                          FALSE,
                                                          &pOperateRoot );

                    if (dwErr == ERROR_SUCCESS)
                    {
                        // 
                        // Iterate over the (real) options.
                        //
                        if (fSwCompare)
                        {
                            VerifyDfsRoots(pOperateRoot, pMasterRoot);
                        }
                        else if (fSwSet)
                        {
                            dwErr = SetDfsRoots(pOperateRoot, pMasterRoot, BackupHandle, fSwNoBackup);
                        }
                        else if (fSwMerge)
                        {
                            dwErr = MergeDfsRoots( pOperateRoot, pMasterRoot, BackupHandle, fSwNoBackup);
                        }
                        
                        pOperateRoot->Close();
                    }
                }
                pMasterRoot->Close();
            }
            break;
            
        }
        else if (fArgImportRoot) 
        {
            DfsRoot *pMasterRoot;
            DfsRoot *pOperateRoot;
            
            dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                  DCToUse,
                                                  Mode,
                                                  FALSE,
                                                  &pOperateRoot );

            if (dwErr == ERROR_SUCCESS)
            {
                dwErr = DfsBuildNameSpaceInformation( &MasterNameSpace,
                                                      DCToUse,
                                                      Mode,
                                                      FALSE,
                                                      &pMasterRoot );
      
                if ((dwErr == ERROR_SUCCESS) &&
                    (fSwVerbose == TRUE))
                {
                    DumpRoots( pMasterRoot, ShowHandle, FALSE);
                }

                if (dwErr == ERROR_SUCCESS)
                {
                    // 
                    // Iterate over the (real) options.
                    //
                    if (fSwCompare)
                    {
                        VerifyDfsRoots(pOperateRoot, pMasterRoot);
                    }
                    
                    else if (fSwMirror)
                    {
                        dwErr = SetDfsRoots(pOperateRoot, pMasterRoot, BackupHandle, fSwNoBackup);
                    }
                    pMasterRoot->Close();
                }
                pOperateRoot->Close();
            }
                    
            break;
        }
        else if (fArgDisplayBlob)
        {
            dwErr = DfsReadFromFile( DisplayBlobFile );          
            break;
        }
        else if (fArgExportBlob)
        {
            dwErr = DfsReadFromAD( OperateNameSpace.GetServerString(),
                                   OperateNameSpace.GetShareString(),
                                   ExportBlobFile,
                                   DCToUse);
            break;
        }
        else if (fSwCheckBlob)
        {  
            dwErr = DfsReadFromAD( OperateNameSpace.GetServerString(),
                                   OperateNameSpace.GetShareString(),
                                   NULL,
                                   DCToUse);
            break;
        }
        else if (fSwView)
        {
            if (fArgDomain) 
            {
                dwErr = DfsEnumerateDomainDfs(pwszDomainName);
            }
            else if (fArgServer) 
            {
               dwErr = DfsEnumerateMachineDfs(pwszServerName);
            }
            else
            {
                DfsRoot *pOperateRoot;

                dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                      DCToUse,
                                                      Mode,
                                                      TRUE,
                                                      &pOperateRoot );
                if (dwErr == ERROR_SUCCESS) 
                {
                    dwErr = DumpRoots( pOperateRoot, ShowHandle, FALSE);

                    pOperateRoot->Close();
                }
            }
            break;
        }
        else if (fArgExport) 
        {
            DfsRoot *pOperateRoot;
            
            dwErr = DfsBuildNameSpaceInformation( &OperateNameSpace,
                                                  DCToUse,
                                                  Mode,
                                                  FALSE,
                                                  &pOperateRoot );
            if (dwErr == ERROR_SUCCESS) 
            {
                dwErr = DumpRoots( pOperateRoot, ExportHandle, TRUE);

                pOperateRoot->Close();
            }           
            
            break;
        }




        if (fSwRenameFtRoot) {
            PVOID DirectModeHandle = NULL;
            
            dwErr = DfsDirectApiOpen( OperateNameSpace.GetPathString(), 
                                      DCToUse,
                                      &DirectModeHandle);

            if (dwErr == ERROR_SUCCESS)
            {
                //
                // Now do the rename. Note that we only use the first component.
                // If users enter /olddomain:\\xx.y.com\z we simply use xx.y.com without
                // the \\ or the sharename.
                //
                dwErr = DfsRenameLinksToDomain( &OperateNameSpace,
                                                OldDomainName.GetServerString(),
                                                NewDomainName.GetServerString());
                if (dwErr == ERROR_SUCCESS) 
                {
                    SetDirectHandleWriteable(DirectModeHandle);
                    dwErr = DfsDirectApiCommitChanges( DirectModeHandle);
                }
                DfsDirectApiClose( DirectModeHandle);
            }
            break;
        }

        if (fSwUnmapFtRoot) {
            dwErr = CmdUnmapRootReplica( OperateNameSpace.GetPathString(),
                                         pwszServerName, 
                                         pwszShareName );

            break;
        }

        if (fArgSiteName)
        {
            DfsString Site;

            dwErr = GetSites( ClientForSiteName.GetString(),
                              &Site );

            if (dwErr == ERROR_SUCCESS)
            {
                ShowInformation((L"\n\nSite for %wS is %wS\n\n",
                                 ClientForSiteName.GetString(),
                                 Site.GetString()));
            }
            break;
        }

        if (fSwInsite || fSwSiteCosting || fSwRootScalability)
        {
            PVOID DirectModeHandle = NULL;
            ULONG Attrib = 0;
            ULONG AttribMask = 0;
            LPWSTR AttribString;

            if (fSwInsite)
            {
                AttribMask = PKT_ENTRY_TYPE_INSITE_ONLY;
                AttribString = L"InSite Referrals";
            }
            else if (fSwSiteCosting)
            {
                AttribMask = PKT_ENTRY_TYPE_COST_BASED_SITE_SELECTION;
                AttribString = L"Cost-based Site Selection";
            }
            else
            {
                AttribMask = PKT_ENTRY_TYPE_ROOT_SCALABILITY;
                AttribString = L"Root Scalability";
            }

            dwErr = DfsDirectApiOpen( OperateNameSpace.GetPathString(), 
                                      DCToUse,
                                      &DirectModeHandle);


            if (dwErr == ERROR_SUCCESS)
            {

                dwErr = DfsExtendedRootAttributes( DirectModeHandle,
                                                   &Attrib,
                                                   OperateNameSpace.GetRemainingCountedString(),
                                                   FALSE );
                if (dwErr == ERROR_SUCCESS) {
                    
                    if (fSwDisplay) {
                        MyPrintf(L"Namespace %ws: %ws %ws\n",
                                 OperateNameSpace.GetPathString(),
                                 AttribString,
                                 ((Attrib & AttribMask) == AttribMask) ? L"ENABLED" : L"DISABLED");
                    } else {

                        SetDirectHandleWriteable(DirectModeHandle);

                        if (fSwEnable)  Attrib |= AttribMask;
                        else         Attrib &= ~AttribMask;

                        dwErr = DfsExtendedRootAttributes( DirectModeHandle,
                                                           &Attrib,
                                                           OperateNameSpace.GetRemainingCountedString(),
                                                           TRUE );
                        if (dwErr == ERROR_SUCCESS)
                        {
                            dwErr = DfsDirectApiCommitChanges( DirectModeHandle);
                        }

                        if (dwErr == ERROR_SUCCESS)
                        {
                            (VOID) ReSynchronizeRootTargetsFromPath(&OperateNameSpace);
                        }
                    }
                }
                
                DfsDirectApiClose( DirectModeHandle);
            }
            else if (fSwInsite)
            {
                DWORD PrevErr = dwErr; // Save this error in case of failure

                DebugInformation((L"Failure getting Windows .Net ExtendedAttributes for %wZ, Status 0x%x\n",
                    OperateNameSpace.GetPathCountedString(), dwErr));

                // Get the existing attrs. The root name will have to match although it's win2k.
                dwErr = DfsExtendedWin2kRootAttributes( &OperateNameSpace, &Attrib, FALSE );
                if (dwErr == ERROR_SUCCESS)
                {
                    if (fSwDisplay) {
                        MyPrintf(L"Namespace %ws: %ws %ws\n",
                                 OperateNameSpace.GetPathString(),
                                 AttribString,
                                 ((Attrib & AttribMask) == AttribMask) ? L"ENABLED" : L"DISABLED");
                    } 
                    else
                    {
                        if (fSwEnable)  Attrib |= AttribMask;
                        else         Attrib &= ~AttribMask;

                        // Set or reset this attr.
                        dwErr = DfsExtendedWin2kRootAttributes( &OperateNameSpace, &Attrib, TRUE );
                    }
                }
                
                //
                // If we couldn't find a win2k root by this name, then return the original error.
                //
                if (dwErr != ERROR_SUCCESS)
                {
                    dwErr = PrevErr;
                }
            }
            
            break;
        }

        if (fSwPurgeMupCache) {

            dwErr = PurgeMupCache(NULL);
            break;
        }
        
        dwErr = Usage();

    } while( FALSE );



    if (CoInitialized) 
    {
        CoUninitialize();    
    }


    
    if (dwErr == ERROR_SUCCESS) {
        if (CommandSucceeded) {
            ErrorMessage( MSG_SUCCESSFUL );
        } else {
            ErrorMessage( MSG_COMMAND_DONE );
        }
    } else {
        LPWSTR MessageBuffer;
        DWORD dwBufferLength;

        dwBufferLength = FormatMessage(
                            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                            NULL,
                            dwErr,
                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                            (LPWSTR) &MessageBuffer,
                            0,
                            NULL);

        ErrorMessage(MSG_ERROR, dwErr);
        if (dwBufferLength > 0) {
            MyPrintf(L"%ws\r\n", MessageBuffer);
            LocalFree(MessageBuffer);
        }
        ErrorMessage( MSG_COMMAND_DONE );
    }
    WPP_CLEANUP();
    return dwErr;
}


//
//  This is a laborious function that checks the current
//  argument for a match. DfsDbgPrints here are just
//  examples of random optimism: the /Verbose option has to
//  come before the current argument in order for those
//  lines to get printed.
//
BOOLEAN
CmdProcessArg(LPWSTR Arg)
{
    LONG ArgLen;
    BOOLEAN Terminate = FALSE;
    BOOLEAN FoundAnArg = FALSE;
    DFSSTATUS Status = ERROR_SUCCESS;

    if ( Arg != NULL && wcslen(Arg) > 1) {

        Terminate = FALSE;
        ArgLen = wcslen(Arg);

        if (_wcsnicmp(Arg, ArgRemFtRoot, ArgLenRemFtRoot) == 0) {
            FoundAnArg = fArgRemFtRoot = TRUE;
            if (ArgLen > ArgLenRemFtRoot)
                pwszLogicalName = &Arg[ArgLenRemFtRoot];
        } else if (_wcsnicmp(Arg, ArgShare, ArgLenShare) == 0) {
            FoundAnArg = fArgShare = TRUE;
            if (ArgLen > ArgLenShare)
                pwszShareName = &Arg[ArgLenShare];
            if (pwszLogicalName == NULL)
                pwszLogicalName = pwszShareName;
        } else if (_wcsnicmp(Arg, ArgServer, ArgLenServer) == 0) {
            FoundAnArg = fArgServer = TRUE;
            if (ArgLen > ArgLenServer)
                pwszServerName = &Arg[ArgLenServer];
        } else if (_wcsnicmp(Arg, ArgDomain, ArgLenDomain) == 0) {
            FoundAnArg = fArgDomain = TRUE;
            if (ArgLen > ArgLenDomain)
                pwszDomainName = &Arg[ArgLenDomain];
        } else if (_wcsnicmp(Arg, ArgPktFlush, ArgLenPktFlush) == 0) {
            FoundAnArg = fArgPktFlush = TRUE;
            if (ArgLen > ArgLenPktFlush)
                pwszEntryToFlush = &Arg[ArgLenPktFlush];
        } else if (_wcsnicmp(Arg, ArgSpcFlush, ArgLenSpcFlush) == 0) {
            FoundAnArg = fArgSpcFlush = TRUE;
            if (ArgLen > ArgLenSpcFlush)
                pwszEntryToFlush = &Arg[ArgLenSpcFlush];
        } else if (_wcsnicmp(Arg, ArgLevel, ArgLenLevel) == 0) {
            FoundAnArg = fArgLevel = TRUE;
            if (ArgLen > ArgLenLevel)
                pwszHexValue = &Arg[ArgLenLevel];
        }
        
        //
        //  DfsAdmin options
        //

        else if (_wcsnicmp(Arg, ArgImport, ArgLenImport) == 0)
        {
            FoundAnArg = fArgImport = TRUE;
            ImportFile = &Arg[ArgLenImport];
            if (wcslen(ImportFile) == 0)
            {
                ErrorMessage( MSG_USAGE_IMPORT );
                Terminate = TRUE;
                ImportFile = NULL;
            }
        }
        else if (_wcsnicmp(Arg, ArgDisplayBlob, ArgLenDisplayBlob) == 0)
        {
            FoundAnArg = fArgDisplayBlob = TRUE;
            DisplayBlobFile = &Arg[ArgLenDisplayBlob];
            if (wcslen(DisplayBlobFile) == 0)
            {
                ErrorMessage( MSG_USAGE_DISPLAY_BLOB );
                Terminate = TRUE;
                ImportFile = NULL;
            }
        }
        else if (_wcsnicmp(Arg, ArgExportBlob, ArgLenExportBlob) == 0)
        {
            FoundAnArg = fArgExportBlob = TRUE;
            ExportBlobFile = &Arg[ArgLenExportBlob];
            if (wcslen(ExportBlobFile)==0)
            {
                ErrorMessage( MSG_USAGE_EXPORT_BLOB );
                Terminate = TRUE;
                ExportBlobFile = NULL;
            }
        }
        else if (_wcsnicmp(Arg, ArgExport, ArgLenExport) == 0)
        {
            FoundAnArg = fArgExport = TRUE;
            ExportFile = &Arg[ArgLenExport];
            if (wcslen(ExportFile) == 0)
            {
                ErrorMessage( MSG_USAGE_EXPORT );
                Terminate = TRUE;
                ExportFile = NULL;
            }
            else 
            {
                Status = CreateDfsFile(ExportFile, &ExportHandle);
            }
        }
        else if (_wcsnicmp(Arg, ArgBackup, ArgLenBackup) == 0)
        {
            FoundAnArg = fArgBackup = TRUE;
            BackupFile = &Arg[ArgLenBackup];
            if (wcslen(BackupFile) == 0)
            {
                ErrorMessage( MSG_USAGE_EXPORT );
                Terminate = TRUE;
                BackupFile = NULL;
            }
            else 
            {
                Status = CreateDfsFile(BackupFile, &BackupHandle);
            }
        }
        else if (_wcsnicmp(Arg, ArgDebugDC, ArgLenDebugDC) == 0)
        {
            FoundAnArg = fArgDebugDC = TRUE;
            DCToUse = &Arg[ArgLenDebugDC];
            Status = GetDCInformation();
            Mode = MODE_DIRECT;
        }
        else if (_wcsnicmp(Arg, ArgRoot, ArgLenRoot) == 0)
        {
            FoundAnArg = fArgRoot = TRUE;
            Status = OperateNameSpace.CreatePathName(&Arg[ArgLenRoot]);
        }
        else if (_wcsnicmp(Arg, ArgImportRoot, ArgLenImportRoot) == 0)
        {
            FoundAnArg = fArgImportRoot = TRUE;
            Status = MasterNameSpace.CreatePathName(&Arg[ArgLenImportRoot]);
        }
        else if (_wcsnicmp(Arg, ArgDebugFile, ArgLenDebugFile) == 0)
        {
            FoundAnArg = fArgDebugFile = TRUE;
            DebugFile = &Arg[ArgLenDebugFile];
            if (wcslen(DebugFile) == 0)
            {
                //Status = ERROR_INVALID_PARAMETER;
                Terminate = TRUE;
                DebugFile = NULL;
            }
            else {
                Status = CreateDfsFile(DebugFile, &DebugHandle);
            }
        }
        else if (_wcsnicmp(Arg, ArgOldDomain, ArgLenOldDomain) == 0)
        {
            FoundAnArg = fArgOldDomain = TRUE;
            Status = OldDomainName.CreatePathName( &Arg[ArgLenOldDomain] );
        }
        else if (_wcsnicmp(Arg, ArgNewDomain, ArgLenNewDomain) == 0)
        {
            FoundAnArg = fArgNewDomain = TRUE;
            Status = NewDomainName.CreatePathName( &Arg[ArgLenNewDomain] );
        }   
        else if (_wcsnicmp(Arg, ArgUnmapFtRoot, ArgLenUnmapFtRoot) == 0)
        {
            FoundAnArg = fArgUnmapFtRoot = TRUE;
        }
        else if (_wcsnicmp(Arg, ArgViewDfsDirs, ArgLenViewDfsDirs) == 0) {
            FoundAnArg = fArgViewDfsDirs = TRUE;
            pwszVolumeName = &Arg[ArgLenViewDfsDirs];
        }/*
        else if (_wcsnicmp(Arg, ArgRemoveReparse, ArgLenRemoveReparse) == 0) {
            FoundAnArg = fArgRemoveReparse = TRUE;
            pwszDfsDirectoryName = &Arg[ArgLenRemoveReparse];
        }*/
        else if (_wcsnicmp(Arg, ArgSiteName, ArgLenSiteName) == 0)
        {
            FoundAnArg = fArgSiteName = TRUE;
            Status = ClientForSiteName.CreateString(&Arg[ArgLenSiteName]);
        }


        
        // Switches go at the end!!

        else if (_wcsicmp(Arg, SwDebug) == 0) {
            FoundAnArg = fSwDebug = TRUE;
        }
        else if (_wcsicmp(Arg, SwNoBackup) == 0) {
            FoundAnArg = fSwNoBackup = TRUE;
        } else if (_wcsicmp(Arg, SwVerbose) == 0) {
            FoundAnArg = fSwVerbose = TRUE;
        } else if (_wcsicmp(Arg, SwPktFlush) == 0) {
            FoundAnArg = fSwPktFlush = TRUE;
        } else if (_wcsicmp(Arg, SwSpcFlush) == 0) {
            FoundAnArg = fSwSpcFlush = TRUE;
        } else if (_wcsicmp(Arg, SwPktInfo) == 0) {
            FoundAnArg = fSwPktInfo = TRUE;
        } else if (_wcsicmp(Arg, SwSpcInfo) == 0) {
            FoundAnArg = fSwSpcInfo = TRUE;
        } else if (_wcsicmp(Arg, SwDfs) == 0) {
            FoundAnArg = fSwDfs = TRUE;
        } else if (_wcsicmp(Arg, SwAll) == 0) {
            FoundAnArg = fSwSpcInfo = TRUE;    
        } else if (_wcsicmp(Arg, SwQ) == 0) {
            FoundAnArg = fSwQ = fSwHelp = TRUE;
        } else if (_wcsicmp(Arg, SwScriptHelp) == 0) {
            FoundAnArg = fSwScriptHelp = TRUE;
        } else if (_wcsicmp(Arg, SwHelp) == 0) {
            FoundAnArg = fSwHelp = TRUE;
        } else if (_wcsicmp(Arg, SwSet) == 0) {
            FoundAnArg = fSwSet = TRUE;
        } else if (_wcsicmp(Arg, SwMirror) == 0) {
            FoundAnArg = fSwMirror = TRUE;
        } else if (_wcsicmp(Arg, SwRemStdRoot) == 0) {
            FoundAnArg = fSwRemStdRoot = TRUE;
        } else if (_wcsicmp(Arg, SwRemFtRoot) == 0) {
            FoundAnArg = fSwRemFtRoot = TRUE;
        } else if (_wcsicmp(Arg, SwCompare) == 0) {
            FoundAnArg = fSwCompare = TRUE;
        } else if (_wcsicmp(Arg, SwCheckBlob) == 0) {
            FoundAnArg = fSwCheckBlob = TRUE;
        } else if (_wcsicmp(Arg, SwMerge) == 0) {
            FoundAnArg = fSwMerge = TRUE;
        } else if (_wcsicmp(Arg, SwRenameFtRoot) == 0) {
            FoundAnArg = fSwRenameFtRoot = TRUE;
            CmdRequiresDirect = TRUE;
        } else if (_wcsicmp(Arg, SwDirect) == 0) {
            //
            // This is switched on by default when appropriate.
            // If the user specifies this then it means that
            // she only wants to operate in Direct mode.
            //
            FoundAnArg = TRUE;
            fSwDirect = TRUE;
            UserRequiresDirectMode = TRUE;
            Mode = MODE_DIRECT;
        } else if (_wcsicmp(Arg, SwView) == 0) {
            FoundAnArg = fSwView = TRUE;
            ExportHandle = ShowHandle;
        } else if (_wcsicmp(Arg, SwImport) == 0) {
            FoundAnArg = fSwImport = TRUE;
        } else if (_wcsicmp(Arg, SwImportRoot) == 0) {
            FoundAnArg = fSwImportRoot = TRUE;
        } else if (_wcsicmp(Arg, SwBlobSize) == 0) {
            FoundAnArg = fSwBlobSize = TRUE;
        } else if (_wcsicmp(Arg, SwSiteName) == 0) {
            FoundAnArg = fSwSiteName = TRUE;
        } else if (_wcsicmp(Arg, SwExport) == 0) {
            FoundAnArg = fSwExport = TRUE;
        } else if (_wcsicmp(Arg, SwRoot) == 0) {
            FoundAnArg = fSwRoot = TRUE;
        } else if ((_wcsicmp(Arg, SwUnmapFtRoot) == 0) ||
                  (_wcsicmp(Arg, SwUnmap) == 0)) {
            FoundAnArg = fSwUnmapFtRoot = TRUE;
            CmdRequiresDirect = TRUE;
        } else if (_wcsicmp(Arg, SwClean) == 0) {
            //
            // This contacts the target registry directly but doesn't involve a
            // direct mode to do so.
            //
            FoundAnArg = fSwClean = TRUE;
        } else if (_wcsicmp(Arg, SwEnable) == 0) {
            FoundAnArg = fSwEnable = TRUE;
        } else if (_wcsicmp(Arg, SwDisable) == 0) {
            FoundAnArg = fSwDisable = TRUE;
        }  else if (_wcsicmp(Arg, SwDisplay) == 0) {
            FoundAnArg = fSwDisplay = TRUE;
        } else if (_wcsicmp(Arg, SwInsite) == 0) {
            FoundAnArg = fSwInsite = TRUE;
            CmdRequiresDirect = TRUE;
            
        } else if (_wcsicmp(Arg, SwAddStdRoot) == 0) {
            FoundAnArg = fSwAddStdRoot = TRUE;
        } else if (_wcsicmp(Arg, SwAddFtRoot) == 0) {
            FoundAnArg = fSwAddFtRoot = TRUE;
        } else if (_wcsicmp(Arg, SwApi) == 0) {
            FoundAnArg = fSwApi = TRUE;
            Mode = MODE_API;
        } else if (_wcsicmp(Arg, SwRemoveReparse) == 0) {
            FoundAnArg = fSwRemoveReparse = TRUE;
        } else if (_wcsicmp(Arg, SwSiteCosting) == 0) {
            FoundAnArg = fSwSiteCosting = TRUE;
            CmdRequiresDirect = TRUE;
        } else if (_wcsicmp(Arg, SwRootScalability) == 0) {
            FoundAnArg = fSwRootScalability = TRUE;
            CmdRequiresDirect = TRUE;
        } else if (_wcsicmp(Arg, SwPurgeMupCache) == 0) {
            FoundAnArg = fSwPurgeMupCache = TRUE;
        }
        else if (_wcsicmp(Arg, SwUpdateWin2kStaticSiteTable) == 0) {
            FoundAnArg = fSwUpdateWin2kStaticSiteTable = TRUE;
            CmdRequiresDirect = TRUE;
        }
        else if (_wcsicmp(Arg, SwShowWin2kStaticSiteTable) == 0) {
            FoundAnArg = fSwShowWin2kStaticSiteTable = TRUE;
            CmdRequiresDirect = TRUE;
        }
        else if (_wcsicmp(Arg, SwPurgeWin2kStaticSiteTable) == 0) {
            FoundAnArg = fSwPurgeWin2kStaticSiteTable = TRUE;
            CmdRequiresDirect = TRUE;
        }
        else if (_wcsicmp(Arg, SwViewDfsDirs) == 0) {
            FoundAnArg = fSwViewDfsDirs = TRUE;
        }
        else if (_wcsicmp(Arg, SwDisplayBlob) == 0) {
            FoundAnArg = fSwDisplayBlob = TRUE;
        }
        else if (_wcsicmp(Arg, SwExportBlob) == 0) {
            FoundAnArg = fSwExportBlob = TRUE;
        }

        //
        // Done processing Arguments and Switches. 
        // Decide whether to terminate or not.
        //
        if (FoundAnArg == FALSE) {
            ErrorMessage(MSG_UNRECOGNIZED_OPTION, &Arg[1]);
            Terminate = TRUE;
        }

        if (Status != ERROR_SUCCESS)
        {
            ErrorMessage(MSG_ERROR, Status);
            Terminate = TRUE;
        }
    }

    return Terminate;
}

DWORD
Usage()
{

    ErrorMessage(MSG_USAGE);

    return ERROR_SUCCESS;
}

DFSSTATUS
CmdCheckSyntax( BOOLEAN& Done )
{

    // the following require a namespace to work with
    // BlobSize cmd works without a root.
    #define REQUIRES_ROOT_NAME (fArgExport || fSwRenameFtRoot || fSwInsite || fSwMirror || \
                               (fArgImport && !fSwBlobSize) || \
                               fSwSiteCosting || fArgDebugDC || \
                               fArgImportRoot || fSwRootScalability || \
                               fArgExportBlob || fSwCheckBlob)

    DFSSTATUS dwErr = ERROR_SUCCESS;
    Done = FALSE;
    
    do {
        if ((fSwHelp == TRUE) || 
           ((OperateNameSpace.IsEmptyPath() == TRUE) && (REQUIRES_ROOT_NAME) ))
        {
        
            if (fArgImport || fSwImport || fSwBlobSize) {
                ErrorMessage( MSG_USAGE_IMPORT );
            } else if (fArgExport || fSwExport) {
                ErrorMessage( MSG_USAGE_EXPORT );
            } else if (fSwRenameFtRoot) {
                ErrorMessage( MSG_USAGE_RENAME );
            } else if (fSwUnmapFtRoot) {
                ErrorMessage( MSG_USAGE_UNMAP );
            } else if (fSwClean) {
                ErrorMessage( MSG_USAGE_CLEAN );
            } else if (fSwInsite) {
                ErrorMessage( MSG_USAGE_INSITE );
            } else if (fSwSiteCosting) {
                ErrorMessage( MSG_USAGE_SITECOSTING );
            } else if (fSwAddFtRoot || fSwAddStdRoot) {
                ErrorMessage( MSG_USAGE_ADDROOT );
            } else if (fSwRemFtRoot || fArgRemFtRoot) {
                ErrorMessage( MSG_USAGE_REM_FTROOT );
            } else if (fSwRemStdRoot) {
                ErrorMessage( MSG_USAGE_REM_STDROOT );
            } else if (fArgSiteName || fSwSiteName) {
                ErrorMessage( MSG_USAGE_SITENAME );
            } else if (fSwView) {
                ErrorMessage( MSG_USAGE_VIEW );
            } else if (fArgImportRoot || fSwImportRoot) {
                ErrorMessage( MSG_USAGE_IMPORT_ROOT);
            } else if (fSwCheckBlob) {
                ErrorMessage( MSG_USAGE_CHECK_BLOB );
            } else if (fSwExportBlob || fArgExportBlob) {
                ErrorMessage( MSG_USAGE_EXPORT_BLOB );
            } else if (fSwDisplayBlob || fArgDisplayBlob) {
                ErrorMessage( MSG_USAGE_DISPLAY_BLOB );
            } else if (fSwRootScalability) {
                ErrorMessage( MSG_USAGE_ROOT_SCALABILITY );
            } else if (fSwViewDfsDirs || fArgViewDfsDirs) {
                ErrorMessage( MSG_USAGE_VIEW_DIRS );
            } else if (fSwRemoveReparse) {
                ErrorMessage( MSG_USAGE_VIEW_DIRS );
            } else if (fSwPurgeMupCache) {
                ErrorMessage( MSG_USAGE_PURGE_MUP_CACHE );
            } else if (fSwUpdateWin2kStaticSiteTable ||
                      fSwPurgeWin2kStaticSiteTable ||
                      fSwShowWin2kStaticSiteTable) {
                ErrorMessage( MSG_USAGE_W2K_SITETABLE );
            } else if (fSwPktInfo) {
                ErrorMessage( MSG_USAGE_PKT_INFO );
            } else if (fSwPktFlush) {
                ErrorMessage( MSG_USAGE_PKT_FLUSH );
            } else if (fSwSpcInfo) {
                ErrorMessage( MSG_USAGE_SPC_INFO );
            } else if (fSwSpcFlush) {
                ErrorMessage( MSG_USAGE_SPC_FLUSH );
            } else {
                dwErr = Usage();
            }
            Done = TRUE;
            break;
        }

        if (fSwView) 
        {
            if (!(fArgDomain || fArgRoot || fArgServer || fArgImport)) 
            {
                ErrorMessage(MSG_USAGE_VIEW);
                Done = TRUE;
                break;
            }
        }


        // Set, merge and verify work with import.
        if (fArgImport) {
        
           if (!(fSwSet || fSwMerge || fSwCompare || fSwView || fSwBlobSize)) {

                MyPrintf(L"You must specify one of /View, /Set, /Merge, /BlobSize or /Compare to Import\n");
                ErrorMessage( MSG_USAGE_IMPORT );
                Done = TRUE;
                break;
           }

        }

        if (fSwInsite) {
            if (!(fSwEnable || fSwDisable || fSwDisplay)) {
                MyPrintf(L"You must specify one of /Enable, /Disable or /Display with /Insite command.\n");
                ErrorMessage( MSG_USAGE_INSITE );
                Done = TRUE;
                break;
            }

            if (OperateNameSpace.IsEmptyPath() == TRUE)
            {
                MyPrintf(L"You must specify a DFS root with /Insite command.\n");
                ErrorMessage( MSG_USAGE_INSITE );
                Done = TRUE;
                break;
            }
            if (fSwApi) {
                MyPrintf(L"Insite command does not work in the /Api mode. Use default.\n");
                ErrorMessage( MSG_USAGE_INSITE );
                Done = TRUE;
                break;
            }
        } else if (fSwSiteCosting) {
            if (!(fSwEnable || fSwDisable || fSwDisplay)) {
                MyPrintf(L"You must specify one of /Enable, /Disable or /Display with /SiteCosting command.\n");
                ErrorMessage( MSG_USAGE_SITECOSTING );
                Done = TRUE;
                break;
            }
            if ((OperateNameSpace.IsEmptyPath() == TRUE) ||
                (IsEmptyString(OperateNameSpace.GetRemainingString()) == FALSE))
            {
                MyPrintf(L"You must specify a well-formed DFS root with /SiteCosting command.\n");
                ErrorMessage( MSG_USAGE_SITECOSTING );
                Done = TRUE;
                break;
            }

            if (fSwApi) {
                MyPrintf(L"SiteCosting command does not work in the /Api mode. Use default.\n");
                ErrorMessage( MSG_USAGE_SITECOSTING );
                Done = TRUE;
                break;
            }
        } else if (fSwRootScalability) {
            if (!(fSwEnable || fSwDisable || fSwDisplay)) {
                MyPrintf(L"You must specify one of /Enable, /Disable or /Display with /RootScalability command.\n");
//                ErrorMessage( MSG_USAGE_ROOTSCALABILITY);
                Done = TRUE;
                break;
            }
            if ((OperateNameSpace.IsEmptyPath() == TRUE) ||
                (IsEmptyString(OperateNameSpace.GetRemainingString()) == FALSE))
            {
                MyPrintf(L"You must specify a DFS root with /RootScalability command.\n");
//                ErrorMessage( MSG_USAGE_ROOTSCALABILITY);
                Done = TRUE;
                break;
            }

            if (fSwApi) {
                MyPrintf(L"RootScalability command does not work in the /Api mode. Use default.\n");
//                ErrorMessage( MSG_USAGE_ROOTSCALABILITY);
                Done = TRUE;
                break;
            }
        }   
  

        // These three dont work with any other command (except for /Set with Insite).
        else if ((fSwSet || fSwMerge) &&
                (!fArgImport)) {

           MyPrintf(L"/Set and /Merge options apply only to /Import: command.\n");
           Done = TRUE;
           break;
        }
        else if ((fSwMirror) &&
                (!fArgImportRoot)) {

           MyPrintf(L"/Mirror option applies only to /ImportRoot: command.\n");
           Done = TRUE;
           break;
        }
        else if ((fSwCompare) &&
                ((!fArgImportRoot) && (!fArgImport))) {

           MyPrintf(L"/Compare option applies only to /Import: or /ImportRoot: commands.\n");
           Done = TRUE;
           break;
        }


        if ((fSwView) &&
            (fArgExport || fSwRenameFtRoot)) {

            MyPrintf(L"The /View command cannot be combined with others.\n");
            Usage();
            Done = TRUE;
            break;
        }

        if (fSwRenameFtRoot) {

            if (NewDomainName.IsEmptyPath() == TRUE ||
               OldDomainName.IsEmptyPath() == TRUE ||
               (OperateNameSpace.IsEmptyPath() == TRUE))
            {
                ErrorMessage( MSG_USAGE_RENAME );
                Done = TRUE;
                break;
            }
            DebugInformation((L"DfsUtil: New domain name will be %wS\n", NewDomainName.GetServerString()));
            DebugInformation((L"DfsUtil: Old domain to be renamed is %wS\n", OldDomainName.GetServerString()));
        }   
                         


        if ((fArgUnmapFtRoot) || // Arg gets an automatic usage.

            ((fSwUnmapFtRoot) &&
             ( (OperateNameSpace.IsEmptyPath() == TRUE) ||
               (pwszServerName == NULL) ||
               (pwszShareName == NULL)))) {

              ErrorMessage( MSG_USAGE_UNMAP );
              Done = TRUE;
              break;
        }

        if ((fArgClean) || // Arg gets an automatic usage.

            ((fSwClean) &&
             ((pwszServerName == NULL) ||
              (pwszShareName == NULL)))) {

              ErrorMessage( MSG_USAGE_CLEAN );
              Done = TRUE;
              break;
        }

        if (fSwClean)
        {
            DWORD Status;
            
            //
            // We don't allow domain names here. That can lead to incorrect
            // results as well as data loss.
            //
            Status = IsThisADomainName( pwszServerName, NULL );
            if (Status == ERROR_SUCCESS)
            {
                MyPrintf(L"/Server: parameter must be the name of a DFS root server. It cannot be a domain name\n");
                ErrorMessage( MSG_USAGE_CLEAN );
                Done = TRUE;
                break;
            }
        }
        
        if ( fSwAddStdRoot && 
            (IsEmptyString( pwszServerName ) || IsEmptyString( pwszShareName ))) {
            MyPrintf(L"You must specify a valid target server and a share for the new root\n");
            ErrorMessage( MSG_USAGE_ADDROOT );
            Done = TRUE;
            break;
        }

        if ((fArgRemFtRoot || fSwRemFtRoot || fSwRemStdRoot) && 
            (IsEmptyString( pwszServerName ) || IsEmptyString( pwszShareName ))) {

            MyPrintf(L"You must specify a valid target server and a share to remove.\n");
            if (fSwRemStdRoot)
                ErrorMessage( MSG_USAGE_REM_STDROOT );
            else
                ErrorMessage( MSG_USAGE_REM_FTROOT );
            
            Done = TRUE;
            break;
        }

        /*if ((fArgRemoveReparse) && // Arg gets an automatic usage.

              (pwszDfsDirectoryName == NULL)) {
               MyPrintf(L"You must specify a volume name\n");
              Done = TRUE;
              break;
        }*/

        if (fArgViewDfsDirs) {
            if (pwszVolumeName == NULL) {
                MyPrintf(L"You must specify a directory name\n");
                Done = TRUE;
                break;
            }
            if (wcschr(pwszVolumeName, ':') == NULL) {
                MyPrintf(L"The volume drive letter must contain a colon at the end.\n");
                ErrorMessage( MSG_USAGE_VIEW_DIRS );
                Done = TRUE;
                break;
            }
        }

        //
        // If at this point we have a root:\\x\y, we need to make sure that we have
        // exactly two path components. It is too cumbersome to use REQUIRES_ROOT_NAME
        // check here because there are options like /View that needs /Root only for some cases.
        //
        if ((OperateNameSpace.IsEmptyPath() != TRUE) &&
            ((IsEmptyString(OperateNameSpace.GetShareString()) == TRUE) ||
             (IsEmptyString(OperateNameSpace.GetRemainingString()) == FALSE)) &&
            (fSwInsite == FALSE))
            {
                MyPrintf(L"Root must be of the form \\\\DomainOrServer\\RootName.\n");
                Done = TRUE;
                break;
            }

        if (OperateNameSpace.IsEmptyPath() != TRUE)
        {
            //
            // Now that we have valid args, check to see if there are any exceptions to
            // the rules we've applied so far. For example, we Standalone roots
            // and Direct mode won't mix well for some switches of /Import cmd.
            //
            dwErr = CmdCheckExceptions( &OperateNameSpace );
            if (dwErr != ERROR_SUCCESS)
            {
                Done = TRUE;
                break;
            }
        }

        if (MasterNameSpace.IsEmptyPath() != TRUE)
        {
            dwErr = CmdCheckExceptions( &MasterNameSpace );
            if (dwErr != ERROR_SUCCESS)
            {
                Done = TRUE;
                break;
            }
        }
        
        if (fArgDebugDC != NULL)
        {
            if (DCInfoStatus != ERROR_SUCCESS)
            {
                MyPrintf(L"Could not get information from DC %wS, error 0x%x\n",
                         DCToUse, DCInfoStatus);
                Done = TRUE;
                break;
            }
            if (OperateNameSpace.IsEmptyPath() != TRUE)
            {
                if (DfsIsThisADomainName(OperateNameSpace.GetServerString()) == ERROR_SUCCESS)
                {
                    if ((RtlCompareUnicodeString(OperateNameSpace.GetServerCountedString(), &DCToUseFlatDomainName, TRUE) != 0)
                         &&
                         (RtlCompareUnicodeString(OperateNameSpace.GetServerCountedString(), &DCToUseDNSDomainName, TRUE) != 0))
                    {
                        MyPrintf(L"DC %ws belongs to %wZ domain, and not to %wS domain\n",
                                 DCToUse, &DCToUseDNSDomainName, OperateNameSpace.GetServerString());

                        Done = TRUE;
                        break;
                    }
                }
            }
            if (MasterNameSpace.IsEmptyPath() != TRUE)
            {   
                if (DfsIsThisADomainName(MasterNameSpace.GetServerString()) == ERROR_SUCCESS)
                {
                    if ((RtlCompareUnicodeString(MasterNameSpace.GetServerCountedString(), &DCToUseFlatDomainName, TRUE) != 0)
                         &&
                         (RtlCompareUnicodeString(MasterNameSpace.GetServerCountedString(), &DCToUseDNSDomainName, TRUE) != 0))
                    {
                        MyPrintf(L"DC %ws belongs to %wZ domain, and not to %wS domain\n",
                                 DCToUse, &DCToUseDNSDomainName, MasterNameSpace.GetServerString());
                        Done = TRUE;
                        break;

                    }
                }
            }
        
        }
        
    } while (FALSE);

    return dwErr;
}

DFSSTATUS
CmdInitializeDirectMode(
    PBOOLEAN pCoInitialized)
{
    DFSSTATUS Status;
    HRESULT Hr = S_OK;
    
    *pCoInitialized = FALSE;

    Hr = CoInitializeEx(NULL,COINIT_MULTITHREADED| COINIT_DISABLE_OLE1DDE);
    if (Hr == S_OK)
    {
        *pCoInitialized = TRUE;
        Status = DfsServerLibraryInitialize(DFS_DIRECT_MODE|DFS_DONT_SUBSTITUTE_PATHS);
    }
    else
    {
        Status = DfsGetErrorFromHr(Hr);
    }

    return Status;
}


DWORD
ReSynchronizeRootTargets(
    IN LPWSTR PathString)
{
    DfsPathName PathName;
    DFSSTATUS Status;

    Status = PathName.CreatePathName(PathString);
    if (Status == ERROR_SUCCESS)
    {
        Status = ReSynchronizeRootTargetsFromPath(&PathName);
    }
    return Status;
}


DWORD
ReSynchronizeRootTargetsFromPath(
    IN DfsPathName *pPathName)
{
    DFSSTATUS Status, SetStatus;
    LPBYTE pBuffer = NULL;
    DWORD ResumeHandle = 0;
    DWORD EntriesRead = 0;
    DWORD PrefMaxLen = 1;
    DWORD Level = 4;
    PDFS_INFO_4 pCurrentBuffer;
    DWORD i; 
    PDFS_STORAGE_INFO pStorage;
    LPWSTR DfsPathString;

    DfsPathString = pPathName->GetPathString();
    //
    // We are reading in just the ROOT.
    //
    Status = DfsApiEnumerate( MODE_DIRECT,
                              DfsPathString, 
                              Level, 
                              PrefMaxLen, 
                              &pBuffer, 
                              &EntriesRead, 
                              &ResumeHandle);
    
    if ((Status == ERROR_SUCCESS) && EntriesRead != 0)
    {   
        pCurrentBuffer = (PDFS_INFO_4)pBuffer;

        //
        // Now contact the appropriate server(s) for the root replicas
        // and ask them to re-read their roots. Things have been
        // changed under them.
        //
        
        for( i = 0, pStorage = pCurrentBuffer->Storage;
            i < pCurrentBuffer->NumberOfStorages;
            i++, pStorage = pCurrentBuffer->Storage + i )
        {
            SetStatus = SetInfoReSynchronize( pStorage->ServerName, 
                                              pPathName->GetShareString());
            
            //
            //  We just go on to the next server since we don't do any undo's anyway.
            //
            if (SetStatus != ERROR_SUCCESS)
                Status = SetStatus;
        }

        //
        // Free the allocated memory.
        //

        DfsFreeApiBuffer(pBuffer);

    }    
    
    return Status;
}



//
// the following code exists to read and write the old style static
// site table in the AD blob.
//
//
typedef struct _DFS_SITE_UPDATE
{
    UNICODE_STRING Server;
    UNICODE_STRING Site;
    struct _DFS_SITE_UPDATE *pNext;
} DFS_SITE_UPDATE, *PDFS_SITE_UPDATE;

DFS_SITE_UPDATE *pSiteList = NULL;
PDFS_SITE_UPDATE pSiteNext = NULL;
struct _DFS_PREFIX_TABLE *pServerSiteTable;


VOID
DumpSiteInformation(
    PUNICODE_STRING pServer,
    PUNICODE_STRING pSite )
{
    ShowInformation((L"Server %wZ, Site %wZ\n", pServer, pSite));
}

DFSSTATUS
DumpSiteBlob(
    PVOID pBuffer,
    ULONG Size,
    BOOLEAN Display )
{

    PVOID pUseBuffer = pBuffer;
    ULONG RemainingSize = Size;
    GUID SiteGuid;
    UNICODE_STRING Server, Site;
    DFSSTATUS Status = ERROR_SUCCESS;
    ULONG Objects = 0, SiteNum, NumSites, Flags;

    if (Size == 0)
    {
        if (Display)
        {
            ShowInformation((L"\nSite Blob with %d sites\n", Objects));
        }
        return Status;
    }

    Status = PackGetGuid(&SiteGuid, &pUseBuffer, &RemainingSize);
    if (Status == ERROR_SUCCESS)
    {
        Status = PackGetULong( &Objects, &pUseBuffer, &RemainingSize );
    }

    if (Display)
    {
        ShowInformation((L"\nSite Blob with %d sites\n", Objects));
    }
    if (Status == ERROR_SUCCESS)
    {
        for (SiteNum = 0; SiteNum < Objects; SiteNum++)
        {
            Status = PackGetString( &Server, &pUseBuffer, &RemainingSize);
            if (Status == ERROR_SUCCESS)
            {
                Status = PackGetULong( &NumSites, &pUseBuffer, &RemainingSize);
            }
            if (Status == ERROR_SUCCESS)
            {
                Status = PackGetULong( &Flags, &pUseBuffer, &RemainingSize);
            }
            if (Status == ERROR_SUCCESS)
            {
                Status = PackGetString( &Site, &pUseBuffer, &RemainingSize);
            }
            if (Status != ERROR_SUCCESS)
            {
                break;
            }

            if (Display)
            {
                DumpSiteInformation(&Server, &Site);
            }
        }
    }
    return Status;
}


DFSSTATUS
AddServerToSiteList(
    PUNICODE_STRING pServerName,
    PUNICODE_STRING pSiteName )
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    BOOLEAN Insert = FALSE;
    PDFS_SITE_UPDATE pSiteUpdate;
    UNICODE_STRING RemainingName;
    PVOID pData;
    BOOLEAN SubStringMatch;
    DFSSTATUS Status = ERROR_SUCCESS;



    NtStatus = DfsPrefixTableAcquireWriteLock( pServerSiteTable );
    if ( NtStatus == STATUS_SUCCESS )
    {
        NtStatus = DfsFindUnicodePrefixLocked( pServerSiteTable,
                                               pServerName,
                                               &RemainingName,
                                               &pData,
                                               &SubStringMatch );
        if (NtStatus != STATUS_SUCCESS)
        {
            Insert = TRUE;

            NtStatus = DfsInsertInPrefixTableLocked( pServerSiteTable,
                                                     pServerName,
                                                     pSiteName);
        }
        else
        {
            Insert = FALSE;
            NtStatus = STATUS_SUCCESS;
        }
        DfsPrefixTableReleaseLock( pServerSiteTable );
    }

    if (NtStatus != STATUS_SUCCESS)
    {
        Status = RtlNtStatusToDosError(NtStatus);
    }

    if (Status == ERROR_SUCCESS)
    {
        if (Insert)
        {
            pSiteUpdate = new DFS_SITE_UPDATE;

            if (pSiteUpdate == NULL)
            {
                Status = ERROR_NOT_ENOUGH_MEMORY;
            }

            if (Status == ERROR_SUCCESS)
            {
                Status = DfsCreateUnicodeString( &pSiteUpdate->Server, pServerName);
            }

            if (Status == ERROR_SUCCESS)
            {
                Status = DfsCreateUnicodeString( &pSiteUpdate->Site, pSiteName);
            }

            if (Status == ERROR_SUCCESS)
            {
                pSiteUpdate->pNext = NULL;

                if (pSiteList == NULL)
                {
                    pSiteList = pSiteUpdate;

                }
                else
                {
                    pSiteNext->pNext = pSiteUpdate;
                }
                pSiteNext = pSiteUpdate;
            }
        }
    }

    return Status;
}


DFSSTATUS
ProcessTargetForSite(
    DfsTarget *pTarget )
{
    PUNICODE_STRING pServer, pSite;
    DFSSTATUS Status = ERROR_SUCCESS;

    for (;
         pTarget != NULL;
         pTarget = pTarget->GetNextTarget())
    {
        pServer = pTarget->GetTargetServerCountedString();
        pSite = pTarget->GetTargetSiteCountedString();
        if (pSite->Length != 0)
        {
            Status = AddServerToSiteList( pServer, pSite);
        }
        if (Status != ERROR_SUCCESS)
        {
            break;
        }
    }
    return Status;
}


ULONG
SizeSiteInformationBlob(
    PDFS_SITE_UPDATE pSiteUpdate)
{
    ULONG Size = 0;

    Size += PackSizeString(&pSiteUpdate->Server);
    Size += PackSizeULong();
    Size += PackSizeULong();
    Size += PackSizeString(&pSiteUpdate->Site);

    return Size;
}


DFSSTATUS
UpdateSiteBlob(
    DfsRoot *pRoot)
{
    PDFS_SITE_UPDATE pSiteUpdate;

    GUID NewGuid;
    ULONG TotalObjects = 0;
    DFSSTATUS Status;
    ULONG SiteBlobSize;
    PBYTE pBuffer;
    PVOID pUseBuffer;
    ULONG SizeRemaining;

    pSiteUpdate = pSiteList;

    Status = UuidCreate(&NewGuid);
    if (Status != ERROR_SUCCESS)
    {
        return Status;
    }

    SiteBlobSize = sizeof(ULONG) + sizeof(GUID);

    pSiteUpdate = pSiteList;
    while (pSiteUpdate != NULL)
    {
        SiteBlobSize += SizeSiteInformationBlob(pSiteUpdate);
        TotalObjects++;
        pSiteUpdate = pSiteUpdate->pNext;
    }

    pBuffer = new BYTE[SiteBlobSize];
    if (pBuffer == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pUseBuffer = pBuffer;
    SizeRemaining = SiteBlobSize;

    Status = PackSetGuid( &NewGuid, &pUseBuffer, &SizeRemaining);
    if (Status == ERROR_SUCCESS)
    {
        Status = PackSetULong( TotalObjects, &pUseBuffer, &SizeRemaining );
    }

    pSiteUpdate = pSiteList;
    while (pSiteUpdate != NULL)
    {
        Status = PackSetString( &pSiteUpdate->Server, &pUseBuffer, &SizeRemaining );
        if (Status == ERROR_SUCCESS)
        {
            //
            // We allow only 1 site information for each server.
            //
            Status = PackSetULong( 1, &pUseBuffer, &SizeRemaining );
        }

        if (Status == ERROR_SUCCESS)
        {
            //
            // Flags: alwyas 0.
            //

            Status = PackSetULong( 0, &pUseBuffer, &SizeRemaining );
        }


        if (Status == ERROR_SUCCESS)
        {
            Status = PackSetString( &pSiteUpdate->Site, &pUseBuffer, &SizeRemaining );
        }

        pSiteUpdate = (PDFS_SITE_UPDATE)(pSiteUpdate->pNext);
    }


    if (Status == ERROR_SUCCESS)
    {
        PUNICODE_STRING pRootToUpdate = pRoot->GetLinkNameCountedString();
        pRoot->SetRootApiName(pRootToUpdate);
        pRoot->SetRootWriteable();

        Status = pRoot->RootSetSiteBlob(pBuffer, SiteBlobSize);
        if (Status == ERROR_SUCCESS)
        {
            Status = pRoot->UpdateMetadata();
        }
    }

    delete [] pBuffer;

    return Status;
}


DFSSTATUS
PurgeSiteBlob(
    DfsRoot *pRoot)
{
    PDFS_SITE_UPDATE pSiteUpdate = NULL;

    GUID NewGuid;
    ULONG TotalObjects = 0;
    DFSSTATUS Status = ERROR_SUCCESS;
    ULONG SiteBlobSize = 0;
    PBYTE pBuffer = NULL;
    PVOID pUseBuffer = NULL;
    ULONG SizeRemaining = 0;

    pSiteUpdate = pSiteList;

    Status = UuidCreate(&NewGuid);
    if (Status != ERROR_SUCCESS)
    {
        return Status;
    }

    SiteBlobSize = sizeof(ULONG) + sizeof(GUID);

    pBuffer = new BYTE[SiteBlobSize];
    if (pBuffer == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pUseBuffer = pBuffer;
    SizeRemaining = SiteBlobSize;

    Status = PackSetGuid( &NewGuid, &pUseBuffer, &SizeRemaining);
    if (Status == ERROR_SUCCESS)
    {
        Status = PackSetULong( TotalObjects, &pUseBuffer, &SizeRemaining );
    }


    if (Status == ERROR_SUCCESS)
    {
        PUNICODE_STRING pRootToUpdate = pRoot->GetLinkNameCountedString();
        pRoot->SetRootApiName(pRootToUpdate);
        pRoot->SetRootWriteable();

        Status = pRoot->RootSetSiteBlob(pBuffer, SiteBlobSize);
        if (Status == ERROR_SUCCESS)
        {
            pRoot->UpdateMetadata();
        }
    }

    delete [] pBuffer;

    return Status;
}




DFSSTATUS
ProcessRootForSite(
    DfsRoot *pRoot )
{
    DFSSTATUS Status = ERROR_SUCCESS;
    DfsLink *pLink = NULL;


    Status = DfsInitializePrefixTable( &pServerSiteTable,
                                       FALSE, 
                                       NULL );
    if ( Status != ERROR_SUCCESS )
    {
        return Status;
    }

    Status = ProcessTargetForSite(pRoot->GetFirstTarget());

    if (Status == ERROR_SUCCESS)
    {
        for (pLink = pRoot->GetFirstLink();
             pLink != NULL;
             pLink = pLink->GetNextLink())
        {
            Status = ProcessTargetForSite( pLink->GetFirstTarget());
            if (Status != ERROR_SUCCESS)
            {
                break;
            }
        }
    }

    if (Status == ERROR_SUCCESS)
    {
        Status = UpdateSiteBlob(pRoot);
    }
    return Status;
}

DFSSTATUS
PurgeSiteInformationForRoot(
    DfsRoot *pRoot )
{
    DFSSTATUS Status = ERROR_SUCCESS;

    Status = DfsInitializePrefixTable( &pServerSiteTable,
                                       FALSE, 
                                       NULL );
    if ( Status != ERROR_SUCCESS )
    {
        return Status;
    }


    if (Status == ERROR_SUCCESS)
    {
        Status = PurgeSiteBlob(pRoot);
    }
    return Status;
}

DFSSTATUS
IsRootStandalone( 
    DfsPathName *Namespace,
    BOOLEAN& IsStandalone )
{
    DFSSTATUS Status;
    LPBYTE  pBuffer = NULL;
    DWORD RootFlavor = 0;
    
    IsStandalone = FALSE;
    Status = NetDfsGetInfo( Namespace->GetPathCountedString()->Buffer, NULL, NULL, 3, &pBuffer );

    if (Status == ERROR_SUCCESS) {
        RootFlavor = ((PDFS_INFO_3)pBuffer)->State & DFS_VOLUME_FLAVORS;

        //
        // There is no real easy way to find out the type of a Win2K root. The FLAVORS bit
        // is post-win2k. In that case, err on the safe side and return Standalone.
        //
        if (RootFlavor == 0)
        {
            DebugInformation((L"NetDfsGetInfo returns 0 for DFS_VOLUME_FLAVORS. Assuming a standalone root\n"));
            IsStandalone = TRUE;
        }
        else if (RootFlavor == DFS_VOLUME_FLAVOR_STANDALONE) 
        {
            IsStandalone = TRUE;
        }
        NetApiBufferFree( pBuffer );
    }

    return Status;
}



//+----------------------------------------------------------------------------
//
//  Function:   IsThisADomainName
//
//  Synopsis:   Calls the mup to have it check the special name table to see if the
//              name matches a domain name.  Returns a list of DC's in the domain,
//              as a list of strings.  The list is terminated with a double-null.
//
//  Arguments:  [wszName] -- Name to check
//              [ppList]  -- Pointer to pointer for results.
//
//  Returns:    [ERROR_SUCCESS] -- Name is indeed a domain name.
//
//              [ERROR_FILE_NOT_FOUND] -- Name is not a domain name
//
//-----------------------------------------------------------------------------

DWORD
IsThisADomainName(
    IN LPWSTR wszName,
    OUT PWCHAR *ppList OPTIONAL)
{
    NTSTATUS NtStatus;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES objectAttributes;
    UNICODE_STRING DfsDriverName;
    HANDLE DriverHandle = NULL;
    DWORD dwErr;
    PCHAR OutBuf = NULL;
    ULONG Size = 0x100;
    ULONG Count = 0;

    RtlInitUnicodeString(&DfsDriverName, DFS_DRIVER_NAME);

    InitializeObjectAttributes(
        &objectAttributes,
        &DfsDriverName,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
    );

    NtStatus = NtCreateFile(
                    &DriverHandle,
                    SYNCHRONIZE,
                    &objectAttributes,
                    &IoStatusBlock,
                    NULL,
                    FILE_ATTRIBUTE_NORMAL,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    FILE_OPEN_IF,
                    FILE_CREATE_TREE_CONNECTION | FILE_SYNCHRONOUS_IO_NONALERT,
                    NULL,
                    0
                );

    if (!NT_SUCCESS(NtStatus)) {
        return ERROR_FILE_NOT_FOUND;
    }

Retry:

    OutBuf = (PCHAR)malloc(Size);

    if (OutBuf == NULL) {

        NtClose(DriverHandle);
        return ERROR_NOT_ENOUGH_MEMORY;

    }

    NtStatus = NtFsControlFile(
                   DriverHandle,
                   NULL,       // Event,
                   NULL,       // ApcRoutine,
                   NULL,       // ApcContext,
                   &IoStatusBlock,
                   FSCTL_DFS_GET_SPC_TABLE,
                   wszName,
                   (wcslen(wszName) + 1) * sizeof(WCHAR),
                   OutBuf,
                   Size
               );

    if (NtStatus == STATUS_SUCCESS) {

        dwErr = ERROR_SUCCESS;

    } else if (NtStatus == STATUS_BUFFER_OVERFLOW && ++Count < 5) {

        Size = *((ULONG *)OutBuf);
        free(OutBuf);
        goto Retry;
    
    } else {

        dwErr = ERROR_FILE_NOT_FOUND;

    }

    NtClose(DriverHandle);

    if (ppList == NULL)
    {
        free(OutBuf);
        OutBuf = NULL;
    }
    else
    {
        *ppList = (WCHAR *)OutBuf;
    }
    
    return dwErr;
}

DFSSTATUS
CmdCheckExceptions( 
    DfsPathName *pNameSpace)
{
    DFSSTATUS Status = ERROR_SUCCESS;

    //
    // 733898 : disable /Import and /ImportRoot writable operations
    // over direct mode for standalone roots. This is so that 
    // we won't race with DfsSvc's synchronize and possibly
    // create inconsistencies. 
    // Besides since direct mode registry blob updates aren't 
    // 'atomic' import can create inconsistencies anyway.
    //
    if ((fArgImport && (fSwSet || fSwMerge)) 
        || 
       (fArgImportRoot && (fSwMirror)))
    {
        BOOLEAN IsStandalone = FALSE;
        do  {
            Status = IsRootStandalone( pNameSpace, IsStandalone );

            // Err on the safe side if we get an error doing GetInfo.
            if (Status != ERROR_SUCCESS || (IsStandalone))
            {
                if (UserRequiresDirectMode)
                {
                    MyPrintf(L"Import /Set, /Merge and ImportRoot /Mirror commands on Standalone roots must use API mode.\n");
                    ErrorMessage( MSG_USAGE_IMPORT );
                    Status = ERROR_INVALID_PARAMETER;
                    break;
                }

                DebugInformation((L"%ws is a Standalone root. Switching to API mode for this operation.\n", 
                                pNameSpace->GetPathCountedString()->Buffer));
                Mode = MODE_API;
            }

            // Don't return GetInfo errors. Those aren't fatal.
            Status = ERROR_SUCCESS;
      
        } while (FALSE);
    }
    
    return Status;
}