windows-xp/Source/XPSP1/NT/base/fs/dfs/driver/know.c

//+------------------------------------------------------------------
//
//  Copyright (C) 1992, Microsoft Corporation
//
//  File:       Know.C
//
//  Contents:   This file has all the code that involves with knowledge
//              synchronisation on the DC.
//
//  Synoposis:  This code handles the fixing of knowledge inconsistencies.
//              All this code runs only on the DC in response to FSCTRLs from
//              a client etc.
//
//  Functions:  DfsModifyRemotePrefix -
//              DfsCreateRemoteExitPoint -
//              DfsDeleteRemoteExitPoint -
//              DfsTriggerKnowledgeVerification -
//              DfsFsctrlVerifyLocalVolumeKnowledge -
//              DfsFsctrlGetKnowledgeSyncParameters -
//              DfsFsctrlFixLocalVolumeKnowledge -
//
//  History:    22-March-1993   SudK    Created
//              18-June-1992    SudK    Added FixLocalVolumeKnowledge
//
//-------------------------------------------------------------------

#include "dfsprocs.h"
#include <netevent.h>
#include "fsctrl.h"
#include "registry.h"
#include "know.h"
#include "log.h"
#include "localvol.h"
#include "dfswml.h"

#define Dbg     (DEBUG_TRACE_LOCALVOL)


//
//  local function prototypes
//

BOOLEAN
DfsFileExists(
    UNICODE_STRING      DirPath
);

BOOLEAN
DfsFileCreate(
    UNICODE_STRING      DirPath
);

BOOLEAN
DfsFixExitPath(
    PWSTR       ExitPath
);

DfspFixExitPoints(
    PDFS_FIX_LOCAL_VOLUME_ARG   arg
);


#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, DfsModifyRemotePrefix )
#pragma alloc_text( PAGE, DfsCreateRemoteExitPoint )
#pragma alloc_text( PAGE, DfsDeleteRemoteExitPoint )
#pragma alloc_text( PAGE, DfsFileExists )
#pragma alloc_text( PAGE, DfsFileCreate )
#pragma alloc_text( PAGE, DfsStorageIdExists )
#pragma alloc_text( PAGE, DfsFixExitPath )
#pragma alloc_text( PAGE, DfspFixExitPoints )
#pragma alloc_text( PAGE, DfsFsctrlFixLocalVolumeKnowledge )
#endif // ALLOC_PRAGMA


//+------------------------------------------------------------------
//
//  Function:   DfsModifyRemotePrefix
//
//  Synopsis:   This function creates an ExitPoint knowledge at a remote client.
//              Serves as a wrapper and merely makes an FSCTRL to the remote
//              Client.
//
//  Arguments:  [ExitPtId] -- The exit Point ID that needs to be sent across.
//              [remoteHandle] -- The Handle to be used for FSCTRLs.
//
//  Returns:
//
//  History:    22-March-1992   SudK    Created
//
//  Notes:
//
//-------------------------------------------------------------------
NTSTATUS
DfsModifyRemotePrefix(DFS_PKT_ENTRY_ID ExitPtId, HANDLE remoteHandle)
{

    ULONG               size;
    PVOID               buffer = NULL;
    IO_STATUS_BLOCK     ioStatusBlock;
    MARSHAL_BUFFER      marshalBuffer;
    NTSTATUS            status;

    DebugTrace(0, Dbg, "DfsModifyRemotePrefix: %ws\n", ExitPtId.Prefix.Buffer);

    size = 0L;
    status = DfsRtlSize(&MiPktEntryId, &ExitPtId, &size);
    if (NT_SUCCESS(status)) {

        buffer = ExAllocatePoolWithTag(PagedPool, size, ' sfD');
        if (buffer != NULL)     {
            MarshalBufferInitialize(&marshalBuffer, size, buffer);

            status = DfsRtlPut(
                        &marshalBuffer,
                        &MiPktEntryId,
                        &ExitPtId
                        );
        } else {
            status = STATUS_NO_MEMORY;
        }
    }

    if (NT_SUCCESS(status))     {
        status = ZwFsControlFile(
                    remoteHandle,
                    NULL,
                    NULL,
                    NULL,
                    &ioStatusBlock,
                    FSCTL_DFS_MODIFY_PREFIX,
                    buffer,
                    size,
                    NULL,
                    0
                );

    }

    if (NT_SUCCESS(status))
        status = ioStatusBlock.Status;

    if (buffer != NULL)
        ExFreePool(buffer);

    return(status);

}



//+------------------------------------------------------------------
//
//  Function:   DfsCreateRemoteExitPoint
//
//  Synopsis:   This function creates an ExitPoint knowledge at a remote client.
//              Serves as a wrapper and merely makes an FSCTRL to the remote
//              Client.
//
//  Arguments:  [ExitPtId] -- The exit Point ID that needs to be sent across.
//              [remoteHandle] -- The Handle to be used for FSCTRLs.
//
//  Returns:
//
//  History:    22-March-1992   SudK    Created
//
//  Notes:
//
//-------------------------------------------------------------------
NTSTATUS
DfsCreateRemoteExitPoint(DFS_PKT_ENTRY_ID ExitPtId, HANDLE remoteHandle)
{

    ULONG               size;
    PVOID               buffer = NULL;
    IO_STATUS_BLOCK     ioStatusBlock;
    MARSHAL_BUFFER      marshalBuffer;
    NTSTATUS            status;

    DebugTrace(0, Dbg, "DfsCreateRemoteExitPt: %ws\n", ExitPtId.Prefix.Buffer);

    DFS_TRACE_LOW(PROVIDER, DfsCreateRemoteExitPt_Entry, 
                  LOGGUID(ExitPtId.Uid)
                  LOGUSTR(ExitPtId.Prefix)
                  LOGUSTR(ExitPtId.ShortPrefix)
                  LOGHANDLE(remoteHandle));

    size = 0L;
    status = DfsRtlSize(&MiPktEntryId, &ExitPtId, &size);
    if (NT_SUCCESS(status)) {

        buffer = ExAllocatePoolWithTag(PagedPool, size, ' sfD');
        if (buffer != NULL)     {
            MarshalBufferInitialize(&marshalBuffer, size, buffer);

            status = DfsRtlPut(
                        &marshalBuffer,
                        &MiPktEntryId,
                        &ExitPtId
                        );
        } else {
            status = STATUS_NO_MEMORY;
        }
    }

    if (NT_SUCCESS(status))     {
        status = ZwFsControlFile(
                    remoteHandle,
                    NULL,
                    NULL,
                    NULL,
                    &ioStatusBlock,
                    FSCTL_DFS_CREATE_EXIT_POINT,
                    buffer,
                    size,
                    NULL,
                    0
                );
        DFS_TRACE_ERROR_HIGH(status, ALL_ERROR, DfsCreateRemoteExitPt_Error_ZwFsControlFile,
                             LOGSTATUS(status)
                             LOGGUID(ExitPtId.Uid)
                             LOGUSTR(ExitPtId.Prefix)
                             LOGUSTR(ExitPtId.ShortPrefix)); 
    }

    if (NT_SUCCESS(status))
        status = ioStatusBlock.Status;

    if (buffer != NULL)
        ExFreePool(buffer);

    DFS_TRACE_LOW(PROVIDER, DfsCreateRemoteExitPt_Exit, LOGSTATUS(status)
                  LOGGUID(ExitPtId.Uid)
                  LOGUSTR(ExitPtId.Prefix)
                  LOGUSTR(ExitPtId.ShortPrefix));

    return(status);

}



//+------------------------------------------------------------------
//
//  Function:   DfsDeleteRemoteExitPoint
//
//  Synopsis:   This function deletes a remote exitpoint knowledeg by making
//              an FSCTRL to the remote client.
//
//  Arguments:  [ExitPtId] -- The exit Point ID that needs to be sent across.
//              [remoteHandle] -- The Handle to be used for FSCTRLs.
//
//  Returns:
//
//  History:    22-March-1992   SudK    Created
//
//  Notes:
//
//-------------------------------------------------------------------
NTSTATUS
DfsDeleteRemoteExitPoint(
    IN  DFS_PKT_ENTRY_ID ExitPtId,
    IN  HANDLE remoteHandle
) {
    ULONG               size;
    PVOID               buffer = NULL;
    IO_STATUS_BLOCK     ioStatusBlock;
    MARSHAL_BUFFER      marshalBuffer;
    NTSTATUS            status;

    DebugTrace(0, Dbg, "DeleteRemoteExitPt: %ws\n", ExitPtId.Prefix.Buffer);

    size = 0L;
    status = DfsRtlSize(&MiPktEntryId, &ExitPtId, &size);

    if (NT_SUCCESS(status)) {
        buffer = ExAllocatePoolWithTag(PagedPool, size, ' sfD');
        if (buffer != NULL)     {
            MarshalBufferInitialize(&marshalBuffer, size, buffer);

            status = DfsRtlPut(&marshalBuffer, &MiPktEntryId, &ExitPtId);
        } else {
            status = STATUS_NO_MEMORY;
        }
    }

    if (NT_SUCCESS(status))     {
        status = ZwFsControlFile(remoteHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &ioStatusBlock,
                                 FSCTL_DFS_DELETE_EXIT_POINT,
                                 buffer,
                                 size,
                                 NULL,
                                 0);

    }

    if (NT_SUCCESS(status))
        status = ioStatusBlock.Status;

    if (buffer != NULL)
        ExFreePool(buffer);

    return(status);

}


//+-------------------------------------------------------------------------
//
// Function:    DfsFileExists
//
// Synopsis:    This function verifies the existence of a given directory.
//              It does not create it if it does not exist.
//
// Arguments:   [DirPath] -- The StorageId in the form of UnicodeString.
//
// Returns:     TRUE - If directory exists else FALSE.
//
// History:     15 Jun 1993     SudK    Created
//
//--------------------------------------------------------------------------
BOOLEAN
DfsFileExists(
    UNICODE_STRING      DirPath
)
{
    HANDLE              DirHandle;
    OBJECT_ATTRIBUTES   objectAttributes;
    IO_STATUS_BLOCK     ioStatus;
    NTSTATUS            status;
    BOOLEAN             fPreviousErrorMode;

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

    status = ZwCreateFile(
                        &DirHandle,
                        FILE_LIST_DIRECTORY | FILE_READ_ATTRIBUTES,
                        &objectAttributes,
                        &ioStatus,
                        NULL,
                        FILE_ATTRIBUTE_NORMAL,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                        FILE_OPEN,
                        FILE_DIRECTORY_FILE,
                        NULL,
                        0
             );

    if (NT_SUCCESS(status))     {
        status = ioStatus.Status;
        ZwClose(DirHandle);
    }

    if (NT_SUCCESS(status))
        return(TRUE);
    else if (status == STATUS_NO_MEDIA_IN_DEVICE)
        return(TRUE);
    else
        return(FALSE);

}


//+-------------------------------------------------------------------------
//
// Function:    DfsFileCreate
//
// Synopsis:    This function verifies the existence of a given directory.
//              If it does not exist then it creates it.
//
// Arguments:   [DirPath] -- The StorageId in the form of UnicodeString.
//
// Returns:     TRUE - If it created and all is fine else FALSE.
//
// History:     15 Jun 1993     SudK    Created
//
//--------------------------------------------------------------------------
BOOLEAN
DfsFileCreate(
    UNICODE_STRING      DirPath
)
{
    HANDLE              DirHandle;
    OBJECT_ATTRIBUTES   objectAttributes;
    IO_STATUS_BLOCK     ioStatus;
    NTSTATUS            status;

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

    status = ZwCreateFile(
                        &DirHandle,
                        FILE_LIST_DIRECTORY | FILE_READ_ATTRIBUTES,
                        &objectAttributes,
                        &ioStatus,
                        NULL,
                        FILE_ATTRIBUTE_NORMAL,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                        FILE_OPEN_IF,
                        FILE_DIRECTORY_FILE,
                        NULL,
                        0
             );

    if (NT_SUCCESS(status))     {
        status = ioStatus.Status;
        ZwClose(DirHandle);
    }

    if (!NT_SUCCESS(status))
        return(FALSE);
    else
        return(TRUE);


}



//+-------------------------------------------------------------------------
//
// Function:    DfsStorageIdExists
//
// Synopsis:    This function makes sure that a given storageId exists and if
//              it does not then it attempts to create the storageId if req.
//
// Arguments:   [StorageId] --  The storage id to test in the form of an
//                      NT Path name (eg, \??\C:\foo )
//              [bCreate] --    If this is TRUE, then the function will attempt
//                      to create the stg else it will check for existence.
//
// Returns:     TRUE - If it created and all is fine else FALSE.
//
// History:     15 Jun 1993     SudK    Created
//
//--------------------------------------------------------------------------
BOOLEAN
DfsStorageIdExists(
    UNICODE_STRING      StgPath,
    BOOLEAN             bCreate
)
{
    PWCHAR              pwch = NULL;
    UNICODE_STRING      StorageId;
    BOOLEAN             StgIdCreated = FALSE;

    StorageId = StgPath;
    StorageId.Buffer = ExAllocatePoolWithTag(
                            PagedPool,
                            StorageId.MaximumLength + sizeof(WCHAR),
                            ' sfD');
    
    if (StorageId.Buffer == NULL) {
        return FALSE;
    }

    wcsncpy(StorageId.Buffer, StgPath.Buffer, StgPath.Length/sizeof(WCHAR));
    StorageId.Buffer[StgPath.Length/sizeof(WCHAR)] = UNICODE_NULL;

    ASSERT(StorageId.Length >= wcslen(L"\\??\\C:")*sizeof(WCHAR));
    //
    // If the storage Id refers only to a root drive the trailing backslash
    // may not exist and we need to put it in there to open the right thing.
    //
    if (StorageId.Length < wcslen(L"\\??\\C:\\")*sizeof(WCHAR)) {
        StorageId.Buffer[StorageId.Length/sizeof(WCHAR)] = L'\\';
        StorageId.Buffer[StorageId.Length/sizeof(WCHAR) + 1] = UNICODE_NULL;
    }
    //
    // First verify that the Drive does exist and then we will go into the
    // next stage.
    //
    StorageId.Length = sizeof(L"\\??\\c:\\") - sizeof(UNICODE_NULL);

    if (!DfsFileExists(StorageId))      {
        ExFreePool(StorageId.Buffer);
        return(FALSE);
    }

    //
    // If all that we have is a drive letter then we are done with this step.
    //
    if (wcslen(StorageId.Buffer) <= wcslen(L"\\??\\C:\\"))      {
        ExFreePool(StorageId.Buffer);
        return(TRUE);
    }

    //
    // Now that the drive does exist we can check for each of the directories
    // and create them as we go along.
    //
    pwch = StorageId.Buffer + StorageId.Length/sizeof(WCHAR);

    while (pwch != NULL)        {
        ASSERT(pwch < StorageId.Buffer + StorageId.MaximumLength/sizeof(WCHAR));
        pwch = wcschr(pwch, L'\\');
        if (pwch != NULL)       {
            StorageId.Length = (wcslen(StorageId.Buffer) - wcslen(pwch))*
                                                        sizeof(WCHAR);
            if (bCreate)        {
                if (!DfsFileCreate(StorageId))
                        break;
            }
            else        {
                if (!DfsFileExists(StorageId))
                        break;
            }
            pwch++;     //Skip the last L'\'
        }
        else    {
            StorageId.Length = wcslen(StorageId.Buffer)*sizeof(WCHAR);
            if (bCreate)        {
                if (DfsFileCreate(StorageId))
                        StgIdCreated = TRUE;
            }
            else        {
                if (DfsFileExists(StorageId))
                        StgIdCreated = TRUE;
            }
        }
    }

    //
    // If we came out without the pwch != NULL then it means we were unable
    // to create one of the directories along the way due to some wierd
    // reason. We return a FALSE from this function else a SUCCESS.
    //
    ExFreePool(StorageId.Buffer);
    if (StgIdCreated)
        return(TRUE);
    else
        return(FALSE);

    return(TRUE);
}



//+-------------------------------------------------------------------------
//
// Function:    DfsFixExitPath
//
// Synopsis:    This function makes sure
//
//
//
//--------------------------------------------------------------------------
BOOLEAN
DfsFixExitPath(
    PWSTR       ExitPath
)
{

    UNICODE_STRING      ustrExitPath;
    PWCHAR              pwcLastComponent;
    OBJECT_ATTRIBUTES   objectAttributes;
    HANDLE              exitPtHandle;
    IO_STATUS_BLOCK     ioStatus;
    NTSTATUS            status;

    pwcLastComponent = wcsrchr(ExitPath, L'\\');
    if (pwcLastComponent == NULL)       {
        //
        // This should not happen.
        //
        DebugTrace(0, 1, "DfsFixExitPath: Bad Exitpath %ws given here\n",
                        ExitPath);
        return(FALSE);

    }
    //
    // Now let us verify that everything except for exit pt exists.
    //
    ustrExitPath.Length = (USHORT)(pwcLastComponent - ExitPath);
    ustrExitPath.MaximumLength = ustrExitPath.Length + sizeof(WCHAR);
    ustrExitPath.Buffer = ExitPath;

    if (!DfsStorageIdExists(ustrExitPath, TRUE))      {
        DebugTrace(0, Dbg, "DfsFixExitPath:Fail createstg %wZ\n",&ustrExitPath);
        return(FALSE);
    }

    //
    // Now let us just create the exit pt.
    //
    ustrExitPath.Length = wcslen(ExitPath) * sizeof(WCHAR);
    ustrExitPath.MaximumLength = ustrExitPath.Length + sizeof(WCHAR);

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

    status = ZwCreateFile(
                        &exitPtHandle,
                        DELETE | FILE_READ_ATTRIBUTES,
                        &objectAttributes,
                        &ioStatus,
                        NULL,
                        FILE_ATTRIBUTE_NORMAL,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                        FILE_OPEN_IF,
                        FILE_DIRECTORY_FILE |
                        FILE_SYNCHRONOUS_IO_NONALERT,
                        NULL,
                        0
             );

    if (NT_SUCCESS(status)) {
        ZwClose( exitPtHandle );
        status = ioStatus.Status;
    }

    if (status == STATUS_FILE_IS_A_DIRECTORY) {
        status = STATUS_SUCCESS;
    }

    if (!NT_SUCCESS(status))
        status = DFS_STATUS_BAD_EXIT_POINT;

    if (NT_SUCCESS(status))     {
        return(TRUE);
    }
    else        {
        DebugTrace(0, Dbg, "DfsFixExtPath: Fail create extpath %08lx\n", ULongToPtr( status ));
        DebugTrace(0, Dbg, "DfsFixExtPath: %wZ\n", &ustrExitPath);
        return(FALSE);
    }
}




//+-------------------------------------------------------------------------
//
// Function:    DfspFixExitPoints
//
// Synopsis:    This function ensures that the exit points for a volume are
//              all in place and if not it attempts to create them.
//
// Arguments:   [arg] -- Pointer to DFS_FIX_LOCAL_VOLUME_ARG.
//
// Returns:     STATUS_SUCCESS -- If all went well.
//
// History:     15 Jun 1993     SudK    Created
//
//--------------------------------------------------------------------------
DfspFixExitPoints(
    PDFS_FIX_LOCAL_VOLUME_ARG      arg
)
{
    NTSTATUS                    status = STATUS_SUCCESS;
    LPNET_DFS_ENTRY_ID_CONTAINER pRelInfo;
    ULONG                       i, len, volLen, exitPointLen;
    WCHAR                       wszExitPath[MAX_PATH];
    PWSTR                       pwszExitPath;
    PWCHAR                      pwch;

    pRelInfo = arg->RelationInfo;

    len = wcslen(arg->EntryPrefix);

    volLen = wcslen(arg->VolumeName);

    for (i=0; i < pRelInfo->Count && NT_SUCCESS(status); i++)    {

        exitPointLen = wcslen( pRelInfo->Buffer[i].Prefix );

        if (volLen + exitPointLen < MAX_PATH) {
            pwszExitPath = wszExitPath;
        } else {
            pwszExitPath = ExAllocatePoolWithTag(
                                PagedPool,
                                (volLen + exitPointLen + 1) * sizeof(WCHAR),
                                ' sfD');
        }

        if (pwszExitPath != NULL) {

            wcscpy(pwszExitPath, arg->VolumeName);

            //
            // Now we need to get the last part of the exit path so that
            // we can concatenate to above to get local path to create.
            //

            pwch = pRelInfo->Buffer[i].Prefix + len;

            wcscat(pwszExitPath, pwch);

            //
            // Now we have the local path to create. Call off to appropriate func
            //

            if (!DfsFixExitPath(pwszExitPath))   {
                DebugTrace(0, Dbg, "Unable to forcibly Create %ws exitpath",
                            pwszExitPath);
            }

            if (pwszExitPath != wszExitPath) {
                ExFreePool(pwszExitPath);
            }

        } else {

            status = STATUS_INSUFFICIENT_RESOURCES;

        }

    }

    return(status);

}




//+-------------------------------------------------------------------------
//
// Function:    DfsFsctrlFixLocalVolumeKnowledge
//
// Synopsis:    This function gets called on a server by the DC when the
//              DC discovers a knowledge inconsistency where the server is
//              entirely unaware of a particular volume.
//
// Arguments:
//
// Returns:
//
// History:     15 Jun 1993     SudK    Created.
//
//--------------------------------------------------------------------------
NTSTATUS
DfsFsctrlFixLocalVolumeKnowledge(
    IN PIRP Irp,
    IN PVOID InputBuffer,
    IN ULONG InputBufferLength
)
{

    NTSTATUS                            status = STATUS_SUCCESS;
    MARSHAL_BUFFER                      marshalBuffer;
    PDFS_FIX_LOCAL_VOLUME_ARG           arg;
    PDFS_LOCAL_VOLUME_CONFIG            configInfo;
    ULONG                               i;
    PDFS_PKT                            pkt = _GetPkt();
    UNICODE_STRING                      volume, path, remainingPath;
    PDFS_PKT_ENTRY                      Entry;

    STD_FSCTRL_PROLOGUE(DfsFsctrlFixLocalVolumeKnowledge, TRUE, FALSE);

    if (InputBufferLength < sizeof(*arg)) {
        status = STATUS_INVALID_PARAMETER;
        goto exit_with_status;
    }

    //
    // unmarshal the arguments...
    //

    arg = (PDFS_FIX_LOCAL_VOLUME_ARG) InputBuffer;

    OFFSET_TO_POINTER( arg->VolumeName, arg );
    OFFSET_TO_POINTER( arg->StgId, arg );
    OFFSET_TO_POINTER( arg->EntryPrefix, arg );
    OFFSET_TO_POINTER( arg->ShortPrefix, arg );
    OFFSET_TO_POINTER( arg->RelationInfo, arg );

    if (
        !DfspStringInBuffer(arg->VolumeName, InputBuffer, InputBufferLength) ||
        !DfspStringInBuffer(arg->StgId, InputBuffer, InputBufferLength) ||
        !DfspStringInBuffer(arg->EntryPrefix, InputBuffer, InputBufferLength) ||
        !DfspStringInBuffer(arg->ShortPrefix, InputBuffer, InputBufferLength) ||
        !POINTER_IS_VALID(arg->RelationInfo, InputBuffer, InputBufferLength)
    ) {
        status = STATUS_INVALID_PARAMETER;
        goto exit_with_status;
    }

    if (!POINTER_IN_BUFFER(
            &arg->RelationInfo->Buffer,
            sizeof(arg->RelationInfo->Buffer),
            InputBuffer,
            InputBufferLength)) {
        status = STATUS_INVALID_PARAMETER;
        goto exit_with_status;
    }

    OFFSET_TO_POINTER( arg->RelationInfo->Buffer, arg );

    if (!POINTER_IS_VALID(arg->RelationInfo->Buffer, InputBuffer, InputBufferLength)) {
        status = STATUS_INVALID_PARAMETER;
        goto exit_with_status;
    }

    for (i = 0; i < arg->RelationInfo->Count; i++) {

        if (!POINTER_IN_BUFFER(
                &arg->RelationInfo->Buffer[i].Prefix,
                sizeof(arg->RelationInfo->Buffer[i].Prefix),
                InputBuffer,
                InputBufferLength)) {
            status = STATUS_INVALID_PARAMETER;
            goto exit_with_status;
        }

        OFFSET_TO_POINTER( arg->RelationInfo->Buffer[i].Prefix, arg );

        if (!DfspStringInBuffer(
                arg->RelationInfo->Buffer[i].Prefix,
                InputBuffer,
                InputBufferLength)) {
            status = STATUS_INVALID_PARAMETER;
            goto exit_with_status;
        }

    }

    RtlInitUnicodeString( &volume, arg->VolumeName );

    configInfo = DfsNetInfoToConfigInfo(
                    arg->EntryType,
                    arg->ServiceType,
                    arg->StgId,
                    arg->VolumeName,
                    &arg->EntryUid,
                    arg->EntryPrefix,
                    arg->ShortPrefix,
                    arg->RelationInfo);
    if (configInfo == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Make sure that the storage id is legal
    //

    if (NT_SUCCESS(status)) {
        if (!DfsStorageIdLegal(&volume))      {
            status = DFS_STATUS_STORAGEID_ALREADY_INUSE;
        }
    }

    if (NT_SUCCESS(status)) {

        //
        // Next we need to make sure that we dont already have a local volume
        // with the same prefix. So we acquire resources in the right order.
        //

        ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE);

        //
        // Now we need to acquire the PKT and try to update PKT with new
        // partition's information.
        //

        PktAcquireExclusive(pkt, TRUE);

        //
        // Let us lookup in the PKT first.
        //

        RtlInitUnicodeString( &path, arg->EntryPrefix );

        Entry = PktLookupEntryByPrefix(
                    pkt,
                    &path,
                    &remainingPath);

        //
        // If we already have a local volume with exactly this prefix then we
        // fail this call.
        //

        if ((Entry != NULL) &&
                (Entry->LocalService != NULL) &&
                    (remainingPath.Length == 0))    {

            status = DFS_STATUS_LOCAL_ENTRY;
            goto Cleanup;

        }

        //
        // Now that we are here we have determined that we can go ahead and
        // attempt to perform this operation. First we need to make sure that
        // the required storageId does exist on disk.
        //

        if (!DfsStorageIdExists(volume, TRUE))        {
            status = DFS_STATUS_BAD_STORAGEID;
            goto Cleanup;
        }

        //
        // Next, store the local volume info persistently in the registry.
        //

        status = DfsStoreLvolInfo(
                        configInfo,
                        &volume );

        if (!NT_SUCCESS(status)) {
            DebugTrace(0, Dbg,
                "DfsFsctrlFixLocalVolumeKnowledge: Error storing local volume info %08lx\n", ULongToPtr( status ));
            status = DFS_STATUS_BAD_STORAGEID;
            goto Cleanup;
        }

        //
        // Now we are done with the storing the local volume info in the
        // registry. We still need to make sure that each of the exit Points
        // exist on disk appropriately.
        //

        if (NT_SUCCESS(status)) {
            status = DfspFixExitPoints(arg);
        }

        //
        // Now we need to initialize the PKT with this new partition info.
        //
        if (NT_SUCCESS(status)) {
            status = PktInitializeLocalPartition(
                        pkt,
                        &volume,
                        configInfo);

            if (!NT_SUCCESS(status))    {
                DebugTrace(0, Dbg,
                "DfsFixLocalVolumeKnowledge: Failed PktInitialize %08lx\n",
                ULongToPtr( status ));
            }
        }


Cleanup:

        if (pkt != NULL)
            PktRelease(pkt);

        ExReleaseResourceLite(&DfsData.Resource);

        if (configInfo != NULL)
            ExFreePool( configInfo );

    } else {

        DebugTrace(0,Dbg, "DfsFsctrlFixLocalVolumeKnowledge:Error %08lx\n", ULongToPtr( status ));

    }

exit_with_status:

    DfsCompleteRequest( Irp, status );

    DebugTrace(-1, Dbg,"DfsFsctrlFixLocalVolumeKnowledge:Exit-> %08lx\n", ULongToPtr( status ));

    return status;

}