You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1370 lines
43 KiB
1370 lines
43 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
move.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the routine to rename or copy a file. This
|
|
routine is used by the routines SrvSmbRenameFile,
|
|
SrvSmbRenameFileExtended, and SrvSmbCopyFile.
|
|
|
|
Author:
|
|
|
|
David Treadwell (davidtr) 22-Jan-1990
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "move.tmh"
|
|
#pragma hdrstop
|
|
|
|
#define BugCheckFileId SRV_FILE_MOVE
|
|
|
|
NTSTATUS
|
|
DoCopy (
|
|
IN PWORK_CONTEXT WorkContext,
|
|
IN PUNICODE_STRING Source,
|
|
IN HANDLE SourceHandle,
|
|
IN PUNICODE_STRING Target,
|
|
IN PSHARE TargetShare,
|
|
IN USHORT SmbOpenFunction,
|
|
IN PUSHORT SmbFlags
|
|
);
|
|
|
|
NTSTATUS
|
|
DoRename (
|
|
IN PWORK_CONTEXT WorkContext,
|
|
IN PUNICODE_STRING Source,
|
|
IN HANDLE SourceHandle,
|
|
IN PUNICODE_STRING Target,
|
|
IN PSHARE TargetShare,
|
|
IN USHORT SmbOpenFunction,
|
|
IN PUSHORT SmbFlags,
|
|
IN BOOLEAN FailIfTargetIsDirectory,
|
|
IN USHORT InformationLevel,
|
|
IN ULONG ClusterCount
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text( PAGE, SrvMoveFile )
|
|
#pragma alloc_text( PAGE, DoCopy )
|
|
#pragma alloc_text( PAGE, DoRename )
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
SrvMoveFile(
|
|
IN PWORK_CONTEXT WorkContext,
|
|
IN PSHARE TargetShare,
|
|
IN USHORT SmbOpenFunction,
|
|
IN OUT PUSHORT SmbFlags,
|
|
IN USHORT SmbSearchAttributes,
|
|
IN BOOLEAN FailIfTargetIsDirectory,
|
|
IN USHORT InformationLevel,
|
|
IN ULONG ClusterCount,
|
|
IN PUNICODE_STRING Source,
|
|
IN OUT PUNICODE_STRING Target
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine moves a file, which may be a copy or a rename.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - a pointer to the work context block for the operation. The
|
|
Session, TreeConnect, and RequestHeader fields are used.
|
|
|
|
TargetShare - a pointer to the share on which the target should
|
|
be. The RootDirectoryHandle field is used to do relative opens.
|
|
|
|
SmbOpenFunction - the "OpenFunction" field of the request SMB. This
|
|
parameter is used to determine what should be done if the target
|
|
file does or does not exist.
|
|
|
|
SmbFlags - a pointer to the "Flags" field of the request SMB. This
|
|
parameter is used to determine whether we know that the target
|
|
is supposed to be a file or directory. In addition, if this has
|
|
no information about the target, it is set to reflect whether
|
|
the target was a directory or file. This is useful when doing
|
|
multiple renames or copies as a result of wildcards--move a*.* b
|
|
might call this routine many times, and if b is a directory,
|
|
this routine will set this parameter appropiately such that if
|
|
does not have to reopen the directory for each move.
|
|
|
|
SmbSearchAttributes - the search attributes specified in the request
|
|
SMB. The attributes on the source file are checked against
|
|
these to make sure that the move can be done.
|
|
|
|
FailIfTargetIsDirectory - if TRUE and the target already exists as
|
|
a directory, fail the operation. Otherwise, rename the file
|
|
into the directory.
|
|
|
|
InformationLevel - Move/Rename/CopyOnWrite/Link/MoveCluster
|
|
|
|
ClusterCount - MoveCluster count
|
|
|
|
Source - a pointer to a string describing the name of the source file
|
|
relative to the share directory in which it is located.
|
|
|
|
Target - a pathname to the target file. This may contain directory
|
|
information--it should be the raw information from the SMB,
|
|
unadulterated by the SMB processing routine except for
|
|
canonicalization. This name may end in a directory name, in
|
|
which case the source name is used as the filename.
|
|
|
|
Return Value:
|
|
|
|
Status.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
HANDLE sourceHandle;
|
|
BOOLEAN isCompatibilityOpen;
|
|
PMFCB mfcb;
|
|
PNONPAGED_MFCB nonpagedMfcb;
|
|
PLFCB lfcb;
|
|
|
|
OBJECT_ATTRIBUTES sourceObjectAttributes;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
ULONG sourceAccess = 0;
|
|
BOOLEAN isNtRename;
|
|
ULONG hashValue;
|
|
|
|
PSESSION session;
|
|
PSHARE sourceShare;
|
|
|
|
PSRV_LOCK mfcbLock;
|
|
|
|
PAGED_CODE( );
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) SrvPrint0( "SrvMoveFile entered.\n" );
|
|
|
|
//
|
|
// Set handles and pointers to NULL so we know how to clean up on
|
|
// exit.
|
|
//
|
|
|
|
sourceHandle = NULL;
|
|
isCompatibilityOpen = FALSE;
|
|
lfcb = NULL;
|
|
//mfcb = NULL; // not really necessary--SrvFindMfcb sets it correctly
|
|
|
|
//
|
|
// Set up the block pointers that will be needed.
|
|
//
|
|
|
|
session = WorkContext->Session;
|
|
sourceShare = WorkContext->TreeConnect->Share;
|
|
|
|
isNtRename = (BOOLEAN)(WorkContext->RequestHeader->Command == SMB_COM_NT_RENAME);
|
|
|
|
//
|
|
// See if we already have this file open in compatibility mode. If
|
|
// we do, and this session owns it, then we must use that open
|
|
// handle and, if this is a rename, close all the handles when we
|
|
// are done.
|
|
//
|
|
// *** SrvFindMfcb references the MFCB--remember to dereference it.
|
|
//
|
|
|
|
if ( (WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE) ||
|
|
WorkContext->Session->UsingUppercasePaths ) {
|
|
mfcb = SrvFindMfcb( Source, TRUE, &mfcbLock, &hashValue, WorkContext );
|
|
} else {
|
|
mfcb = SrvFindMfcb( Source, FALSE, &mfcbLock, &hashValue, WorkContext );
|
|
}
|
|
|
|
if ( mfcb != NULL ) {
|
|
nonpagedMfcb = mfcb->NonpagedMfcb;
|
|
ACQUIRE_LOCK( &nonpagedMfcb->Lock );
|
|
}
|
|
|
|
if( mfcbLock ) {
|
|
RELEASE_LOCK( mfcbLock );
|
|
}
|
|
|
|
if ( mfcb == NULL || !mfcb->CompatibilityOpen ) {
|
|
|
|
//
|
|
// Either the file wasn't opened by the server or it was not
|
|
// a compatibility/FCB open, so open it here.
|
|
//
|
|
// Release the open lock--we don't need it any more.
|
|
//
|
|
|
|
if ( mfcb != NULL ) {
|
|
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
|
}
|
|
|
|
//
|
|
// Use DELETE access for a rename, and the appropriate copy access
|
|
// for Copy/Link/Move/MoveCluster.
|
|
//
|
|
|
|
switch (InformationLevel) {
|
|
case SMB_NT_RENAME_RENAME_FILE:
|
|
sourceAccess = DELETE;
|
|
break;
|
|
|
|
case SMB_NT_RENAME_MOVE_CLUSTER_INFO:
|
|
sourceAccess = SRV_COPY_TARGET_ACCESS & ~(WRITE_DAC | WRITE_OWNER);
|
|
break;
|
|
|
|
case SMB_NT_RENAME_SET_LINK_INFO:
|
|
case SMB_NT_RENAME_MOVE_FILE:
|
|
sourceAccess = SRV_COPY_SOURCE_ACCESS;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
SrvInitializeObjectAttributes_U(
|
|
&sourceObjectAttributes,
|
|
Source,
|
|
(WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE ||
|
|
session->UsingUppercasePaths) ? OBJ_CASE_INSENSITIVE : 0L,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
SrvPrint1( "Opening source: %wZ\n",
|
|
sourceObjectAttributes.ObjectName );
|
|
}
|
|
|
|
//
|
|
// Open the source file. We allow read access for other processes.
|
|
//
|
|
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpensForPathOperations );
|
|
|
|
//
|
|
// !!! Currently we can't specify complete if oplocked, because
|
|
// this won't break a batch oplock. Unfortunately this also
|
|
// means that we can't timeout the open (if the oplock break
|
|
// takes too long) and fail this SMB gracefully.
|
|
//
|
|
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&sourceHandle,
|
|
sourceAccess | SYNCHRONIZE, // DesiredAccess
|
|
&sourceObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
FILE_OPEN, // Disposition
|
|
FILE_SYNCHRONOUS_IO_NONALERT // CreateOptions
|
|
| FILE_OPEN_REPARSE_POINT
|
|
| FILE_OPEN_FOR_BACKUP_INTENT,
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
WorkContext->TreeConnect->Share
|
|
);
|
|
|
|
if( status == STATUS_INVALID_PARAMETER ) {
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&sourceHandle,
|
|
sourceAccess | SYNCHRONIZE, // DesiredAccess
|
|
&sourceObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
FILE_OPEN, // Disposition
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
| FILE_OPEN_FOR_BACKUP_INTENT, // CreateOptions
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
WorkContext->TreeConnect->Share
|
|
);
|
|
}
|
|
|
|
if ( NT_SUCCESS(status) ) {
|
|
|
|
SRVDBG_CLAIM_HANDLE( sourceHandle, "MOV", 4, 0 );
|
|
|
|
} else if ( status == STATUS_ACCESS_DENIED ) {
|
|
|
|
//
|
|
// If the user didn't have this permission, update the statistics
|
|
// database.
|
|
//
|
|
SrvStatistics.AccessPermissionErrors++;
|
|
}
|
|
|
|
ASSERT( status != STATUS_OPLOCK_BREAK_IN_PROGRESS );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint1( "SrvMoveFile: SrvIoCreateFile failed (source): %X\n",
|
|
status );
|
|
}
|
|
|
|
goto exit;
|
|
}
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
SrvPrint1( "SrvIoCreateFile succeeded (source), handle = 0x%p\n",
|
|
sourceHandle );
|
|
}
|
|
|
|
SrvStatistics.TotalFilesOpened++;
|
|
|
|
} else {
|
|
|
|
//
|
|
// The file was opened by the server in compatibility mode or as
|
|
// an FCB open.
|
|
//
|
|
|
|
lfcb = CONTAINING_RECORD( mfcb->LfcbList.Blink, LFCB, MfcbListEntry );
|
|
|
|
//
|
|
// Make sure that the session which sent this request is the
|
|
// same as the one which has the file open.
|
|
//
|
|
|
|
if ( lfcb->Session != session ) {
|
|
|
|
//
|
|
// A different session has the file open in compatibility
|
|
// mode, so reject the request.
|
|
//
|
|
|
|
status = STATUS_ACCESS_DENIED;
|
|
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
|
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Set isCompatibilityOpen so that we'll know on exit to close
|
|
// all the open instances of this file.
|
|
//
|
|
|
|
isCompatibilityOpen = TRUE;
|
|
|
|
sourceHandle = lfcb->FileHandle;
|
|
sourceAccess = lfcb->GrantedAccess;
|
|
|
|
}
|
|
|
|
//
|
|
// Make sure that the search attributes jive with the attributes
|
|
// on the file.
|
|
//
|
|
|
|
status = SrvCheckSearchAttributesForHandle( sourceHandle, SmbSearchAttributes );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If the target has length 0, then it is the share root, which must
|
|
// be a directory. If the target is supposed to be a file, fail,
|
|
// otherwise indicate that the target is a directory.
|
|
//
|
|
|
|
if ( Target->Length == 0 ) {
|
|
|
|
if ( *SmbFlags & SMB_TARGET_IS_FILE ) {
|
|
status = STATUS_INVALID_PARAMETER;
|
|
goto exit;
|
|
}
|
|
|
|
*SmbFlags |= SMB_TARGET_IS_DIRECTORY;
|
|
}
|
|
|
|
//
|
|
// We now have the source file open. Call the appropriate routine
|
|
// to rename or copy the file.
|
|
//
|
|
|
|
if (InformationLevel != SMB_NT_RENAME_MOVE_FILE) {
|
|
|
|
status = DoRename(
|
|
WorkContext,
|
|
Source,
|
|
sourceHandle,
|
|
Target,
|
|
TargetShare,
|
|
SmbOpenFunction,
|
|
SmbFlags,
|
|
FailIfTargetIsDirectory,
|
|
InformationLevel,
|
|
ClusterCount
|
|
);
|
|
|
|
} else {
|
|
|
|
FILE_BASIC_INFORMATION fileBasicInformation;
|
|
|
|
//
|
|
// Check whether this is a tree copy request. If so, allow it only if
|
|
// this is a single file copy operation.
|
|
//
|
|
|
|
if ( (*SmbFlags & SMB_COPY_TREE) != 0 ) {
|
|
|
|
//
|
|
// Get the attributes on the file.
|
|
//
|
|
|
|
status = SrvQueryBasicAndStandardInformation(
|
|
sourceHandle,
|
|
NULL,
|
|
&fileBasicInformation,
|
|
NULL
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"SrvMoveFile: NtQueryInformationFile (basic "
|
|
"information) returned %X",
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_QUERY_INFO_FILE, status );
|
|
goto exit;
|
|
}
|
|
|
|
if ( ( fileBasicInformation.FileAttributes &
|
|
FILE_ATTRIBUTE_DIRECTORY ) != 0 ) {
|
|
|
|
//
|
|
// Fail this copy.
|
|
//
|
|
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"Tree copy not implemented.",
|
|
NULL,
|
|
NULL
|
|
);
|
|
status = STATUS_NOT_IMPLEMENTED;
|
|
goto exit;
|
|
}
|
|
|
|
}
|
|
|
|
status = DoCopy(
|
|
WorkContext,
|
|
Source,
|
|
sourceHandle,
|
|
Target,
|
|
TargetShare,
|
|
SmbOpenFunction,
|
|
SmbFlags
|
|
);
|
|
}
|
|
|
|
exit:
|
|
|
|
if ( sourceHandle != NULL && !isCompatibilityOpen ) {
|
|
SRVDBG_RELEASE_HANDLE( sourceHandle, "MOV", 9, 0 );
|
|
SrvNtClose( sourceHandle, TRUE );
|
|
} else if (isCompatibilityOpen &&
|
|
InformationLevel == SMB_NT_RENAME_RENAME_FILE) {
|
|
SrvCloseRfcbsOnLfcb( lfcb );
|
|
}
|
|
|
|
//
|
|
// If the file is open in compatibility mode, then we have held the
|
|
// MFCB lock all along. Release it now.
|
|
//
|
|
|
|
if ( isCompatibilityOpen ) {
|
|
RELEASE_LOCK( &nonpagedMfcb->Lock );
|
|
}
|
|
|
|
if ( mfcb != NULL ) {
|
|
SrvDereferenceMfcb( mfcb );
|
|
}
|
|
|
|
return status;
|
|
|
|
} // SrvMoveFile
|
|
|
|
|
|
NTSTATUS
|
|
DoCopy (
|
|
IN PWORK_CONTEXT WorkContext,
|
|
IN PUNICODE_STRING Source,
|
|
IN HANDLE SourceHandle,
|
|
IN PUNICODE_STRING Target,
|
|
IN PSHARE TargetShare,
|
|
IN USHORT SmbOpenFunction,
|
|
IN PUSHORT SmbFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets up for a call to SrvCopyFile. It opens the target,
|
|
determining, if necessary, whether the target is a file or directory.
|
|
If this information is unknown, it writes it into the SmbFlags
|
|
location.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - a pointer to the work context block for the operation.
|
|
The session pointer is used, and the block itself is used for
|
|
an impersonation.
|
|
|
|
Source - the name of the source file relative to its share.
|
|
|
|
SourceHandle - the handle to the source file.
|
|
|
|
Target - the name of the target file relative to its share.
|
|
|
|
TargetShare - the share of the target file. The RootDirectoryHandle
|
|
field is used for a relative rename.
|
|
|
|
SmbOpenFunction - describes whether we are allowed to overwrite an
|
|
existing file, or we should append to existing files.
|
|
|
|
SmbFlags - can tell if the target is a file, directory, or unknown.
|
|
This routine writes the true information into the location if
|
|
it is unknown.
|
|
|
|
Return Value:
|
|
|
|
Status.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
ULONG createDisposition;
|
|
UNICODE_STRING sourceBaseName;
|
|
BOOLEAN create;
|
|
|
|
HANDLE targetHandle = NULL;
|
|
OBJECT_ATTRIBUTES targetObjectAttributes;
|
|
UNICODE_STRING targetName;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Set the buffer field of targetName to NULL so that we'll know
|
|
// if we have to deallocate it at the end.
|
|
//
|
|
|
|
targetName.Buffer = NULL;
|
|
|
|
//
|
|
// Open the target file. If we know that it is a directory, generate
|
|
// the full file name. Otherwise, open the target as a file.
|
|
//
|
|
|
|
SrvInitializeObjectAttributes_U(
|
|
&targetObjectAttributes,
|
|
Target,
|
|
(WorkContext->RequestHeader->Flags & SMB_FLAGS_CASE_INSENSITIVE ||
|
|
WorkContext->Session->UsingUppercasePaths) ? OBJ_CASE_INSENSITIVE : 0L,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Determine the create disposition from the open function.
|
|
//
|
|
|
|
create = SmbOfunCreate( SmbOpenFunction );
|
|
|
|
if ( SmbOfunTruncate( SmbOpenFunction ) ) {
|
|
createDisposition = create ? FILE_OVERWRITE_IF : FILE_OVERWRITE;
|
|
} else if ( SmbOfunAppend( SmbOpenFunction ) ) {
|
|
createDisposition = create ? FILE_OPEN_IF : FILE_OPEN;
|
|
} else {
|
|
createDisposition = FILE_CREATE;
|
|
}
|
|
|
|
//
|
|
// If we know that the target is a directory, generate the real target
|
|
// name.
|
|
//
|
|
|
|
if ( *SmbFlags & SMB_TARGET_IS_DIRECTORY ) {
|
|
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
|
|
SrvAllocateAndBuildPathName(
|
|
Target,
|
|
&sourceBaseName,
|
|
NULL,
|
|
&targetName
|
|
);
|
|
|
|
if ( targetName.Buffer == NULL ) {
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto copy_done;
|
|
}
|
|
|
|
targetObjectAttributes.ObjectName = &targetName;
|
|
}
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
SrvPrint1( "Opening target: %wZ\n", targetObjectAttributes.ObjectName );
|
|
}
|
|
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpensForPathOperations );
|
|
|
|
//
|
|
// !!! Currently we can't specify complete if oplocked, because
|
|
// this won't break a batch oplock. Unfortunately this also
|
|
// means that we can't timeout the open (if the oplock break
|
|
// takes too long) and fail this SMB gracefully.
|
|
//
|
|
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&targetHandle,
|
|
SRV_COPY_TARGET_ACCESS | SYNCHRONIZE, // DesiredAccess
|
|
&targetObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
createDisposition,
|
|
FILE_NON_DIRECTORY_FILE | // CreateOptions
|
|
FILE_OPEN_REPARSE_POINT |
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
// | FILE_COMPLETE_IF_OPLOCKED,
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
TargetShare
|
|
);
|
|
|
|
if( status == STATUS_INVALID_PARAMETER ) {
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&targetHandle,
|
|
SRV_COPY_TARGET_ACCESS | SYNCHRONIZE, // DesiredAccess
|
|
&targetObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
createDisposition,
|
|
FILE_NON_DIRECTORY_FILE | // CreateOptions
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
// | FILE_COMPLETE_IF_OPLOCKED,
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
TargetShare
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
// If the open failed because the target is a directory, and we didn't
|
|
// know that it was supposed to be a file, then concatenate the
|
|
// source base name to the target and retry the open.
|
|
//
|
|
// !!! NOT THE CORRECT STATUS CODE. It should be something like
|
|
// STATUS_FILE_IS_DIRECTORY.
|
|
|
|
if ( status == STATUS_INVALID_PARAMETER &&
|
|
!( *SmbFlags & SMB_TARGET_IS_FILE ) &&
|
|
!( *SmbFlags & SMB_TARGET_IS_DIRECTORY ) ) {
|
|
|
|
//
|
|
// Set the flags so that future calls to this routine will do
|
|
// the right thing first time around.
|
|
//
|
|
|
|
*SmbFlags |= SMB_TARGET_IS_DIRECTORY;
|
|
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
|
|
SrvAllocateAndBuildPathName(
|
|
Target,
|
|
&sourceBaseName,
|
|
NULL,
|
|
&targetName
|
|
);
|
|
|
|
if ( targetName.Buffer == NULL ) {
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto copy_done;
|
|
}
|
|
|
|
targetObjectAttributes.ObjectName = &targetName;
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
SrvPrint1( "Opening target: %wZ\n", targetObjectAttributes.ObjectName );
|
|
}
|
|
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpenAttempts );
|
|
INCREMENT_DEBUG_STAT( SrvDbgStatistics.TotalOpensForPathOperations );
|
|
|
|
//
|
|
// !!! Currently we can't specify complete if oplocked, because
|
|
// this won't break a batch oplock. Unfortunately this also
|
|
// means that we can't timeout the open (if the oplock break
|
|
// takes too long) and fail this SMB gracefully.
|
|
//
|
|
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&targetHandle,
|
|
SRV_COPY_TARGET_ACCESS | SYNCHRONIZE, // DesiredAccess
|
|
&targetObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
createDisposition,
|
|
FILE_NON_DIRECTORY_FILE | // CreateOptions
|
|
FILE_OPEN_REPARSE_POINT |
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File Type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
TargetShare
|
|
);
|
|
|
|
if( status == STATUS_INVALID_PARAMETER ) {
|
|
status = SrvIoCreateFile(
|
|
WorkContext,
|
|
&targetHandle,
|
|
SRV_COPY_TARGET_ACCESS | SYNCHRONIZE, // DesiredAccess
|
|
&targetObjectAttributes,
|
|
&ioStatusBlock,
|
|
NULL, // AllocationSize
|
|
0, // FileAttributes
|
|
FILE_SHARE_READ, // ShareAccess
|
|
createDisposition,
|
|
FILE_NON_DIRECTORY_FILE | // CreateOptions
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL, // EaBuffer
|
|
0, // EaLength
|
|
CreateFileTypeNone, // File Type
|
|
NULL, // ExtraCreateParameters
|
|
IO_FORCE_ACCESS_CHECK, // Options
|
|
TargetShare
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
if ( targetHandle != NULL ) {
|
|
SRVDBG_CLAIM_HANDLE( targetHandle, "CPY", 5, 0 );
|
|
}
|
|
|
|
//
|
|
// Is the target is a directory, and the copy move is append if exists,
|
|
// create if the file does not exist, fail the request. We must do
|
|
// this, because we have no way of knowing whether the original request
|
|
// expects us append to the file, or truncate it.
|
|
//
|
|
|
|
if ( (*SmbFlags & SMB_TARGET_IS_DIRECTORY) &&
|
|
((SmbOpenFunction & SMB_OFUN_OPEN_MASK) == SMB_OFUN_OPEN_OPEN) &&
|
|
((SmbOpenFunction & SMB_OFUN_CREATE_MASK) == SMB_OFUN_CREATE_CREATE)) {
|
|
|
|
status = STATUS_OS2_CANNOT_COPY;
|
|
goto copy_done;
|
|
|
|
}
|
|
|
|
//
|
|
// If the user didn't have this permission, update the statistics
|
|
// database.
|
|
//
|
|
|
|
if ( status == STATUS_ACCESS_DENIED ) {
|
|
SrvStatistics.AccessPermissionErrors++;
|
|
}
|
|
|
|
ASSERT( status != STATUS_OPLOCK_BREAK_IN_PROGRESS );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint1( "Unable to open target: %X\n", status );
|
|
}
|
|
|
|
goto copy_done;
|
|
}
|
|
|
|
SrvStatistics.TotalFilesOpened++;
|
|
|
|
//
|
|
// Copy the source to the target handle just opened.
|
|
//
|
|
|
|
status = SrvCopyFile(
|
|
SourceHandle,
|
|
targetHandle,
|
|
SmbOpenFunction,
|
|
*SmbFlags,
|
|
(ULONG)ioStatusBlock.Information // TargetOpenAction
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint1( "SrvCopyFile failed, status = %X\n", status );
|
|
}
|
|
}
|
|
|
|
copy_done:
|
|
|
|
if ( targetName.Buffer != NULL ) {
|
|
FREE_HEAP( targetName.Buffer );
|
|
}
|
|
|
|
if ( targetHandle != NULL ) {
|
|
SRVDBG_RELEASE_HANDLE( targetHandle, "CPY", 10, 0 );
|
|
SrvNtClose( targetHandle, TRUE );
|
|
}
|
|
|
|
return status;
|
|
|
|
} // DoCopy
|
|
|
|
|
|
NTSTATUS
|
|
DoRename (
|
|
IN PWORK_CONTEXT WorkContext,
|
|
IN PUNICODE_STRING Source,
|
|
IN HANDLE SourceHandle,
|
|
IN PUNICODE_STRING Target,
|
|
IN PSHARE TargetShare,
|
|
IN USHORT SmbOpenFunction,
|
|
IN OUT PUSHORT SmbFlags,
|
|
IN BOOLEAN FailIfTargetIsDirectory,
|
|
IN USHORT InformationLevel,
|
|
IN ULONG ClusterCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine does the actual rename of an open file. The target may
|
|
be a file or directory, but is bound by the constraints of SmbFlags.
|
|
If SmbFlags does not indicate what the target is, then it is first
|
|
assumed to be a file; if this fails, then the rename if performed
|
|
again with the target as the original target string plus the source
|
|
base name.
|
|
|
|
*** If the source and target are on different volumes, then this
|
|
routine will fail. We could make this work by doing a copy
|
|
then delete, but this seems to be of limited usefulness and
|
|
possibly incorrect due to the fact that a big file would take
|
|
a long time, something the user would not expect.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - a pointer to the work context block for this operation
|
|
used for an impersonation.
|
|
|
|
Source - the name of the source file relative to its share.
|
|
|
|
SourceHandle - the handle to the source file.
|
|
|
|
Target - the name of the target file relative to its share.
|
|
|
|
TargetShare - the share of the target file. The RootDirectoryHandle
|
|
field is used for a relative rename.
|
|
|
|
SmbOpenFunction - describes whether we are allowed to overwrite an
|
|
existing file.
|
|
|
|
SmbFlags - can tell if the target is a file, directory, or unknown.
|
|
This routine writes the true information into the location if
|
|
it is unknown.
|
|
|
|
FailIfTargetIsDirectory - if TRUE and the target already exists as
|
|
a directory, fail the operation. Otherwise, rename the file
|
|
into the directory.
|
|
|
|
InformationLevel - Rename/CopyOnWrite/Link/MoveCluster
|
|
|
|
ClusterCount - MoveCluster count
|
|
|
|
Return Value:
|
|
|
|
Status.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
PFILE_RENAME_INFORMATION fileRenameInformation;
|
|
ULONG renameBlockSize;
|
|
USHORT NtInformationLevel;
|
|
UNICODE_STRING sourceBaseName;
|
|
UNICODE_STRING targetBaseName;
|
|
PWCH s, es;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Allocate enough heap to hold a FILE_RENAME_INFORMATION block and
|
|
// the target file name. Allocate enough extra to hold the source
|
|
// name in case the target turns out to be a directory and we have
|
|
// to concatenate the source and target.
|
|
//
|
|
|
|
renameBlockSize = sizeof(FILE_RENAME_INFORMATION) + Target->Length +
|
|
Source->Length;
|
|
|
|
fileRenameInformation = ALLOCATE_HEAP_COLD(
|
|
renameBlockSize,
|
|
BlockTypeDataBuffer
|
|
);
|
|
|
|
if ( fileRenameInformation == NULL ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint0( "SrvMoveFile: Unable to allocate heap.\n" );
|
|
}
|
|
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
|
|
}
|
|
|
|
//
|
|
// Get the Share root handle.
|
|
//
|
|
|
|
status = SrvGetShareRootHandle( TargetShare );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint1( "DoRename: SrvGetShareRootHandle failed. %X\n", status );
|
|
}
|
|
|
|
FREE_HEAP( fileRenameInformation );
|
|
return(status);
|
|
}
|
|
|
|
//
|
|
// Set up the rename block.
|
|
//
|
|
|
|
if (InformationLevel == SMB_NT_RENAME_MOVE_CLUSTER_INFO) {
|
|
((FILE_MOVE_CLUSTER_INFORMATION *)fileRenameInformation)->ClusterCount =
|
|
ClusterCount;
|
|
} else {
|
|
fileRenameInformation->ReplaceIfExists =
|
|
SmbOfunTruncate( SmbOpenFunction );
|
|
}
|
|
|
|
fileRenameInformation->RootDirectory = TargetShare->RootDirectoryHandle;
|
|
|
|
//
|
|
// If the target file has wildcards, expand name.
|
|
//
|
|
|
|
if ( FsRtlDoesNameContainWildCards( Target ) ) {
|
|
|
|
ULONG tempUlong;
|
|
UNICODE_STRING newTargetBaseName;
|
|
|
|
if (InformationLevel != SMB_NT_RENAME_RENAME_FILE) {
|
|
FREE_HEAP( fileRenameInformation );
|
|
return(STATUS_OBJECT_PATH_SYNTAX_BAD);
|
|
}
|
|
|
|
//
|
|
// Get source and target filenames. The target filename is to be
|
|
// used as a template for wildcard expansion.
|
|
//
|
|
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
SrvGetBaseFileName( Target, &targetBaseName );
|
|
|
|
tempUlong = sourceBaseName.Length + targetBaseName.Length;
|
|
newTargetBaseName.Length = (USHORT)tempUlong;
|
|
newTargetBaseName.MaximumLength = (USHORT)tempUlong;
|
|
newTargetBaseName.Buffer = ALLOCATE_NONPAGED_POOL(
|
|
tempUlong,
|
|
BlockTypeDataBuffer
|
|
);
|
|
|
|
if ( newTargetBaseName.Buffer == NULL ) {
|
|
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"DoRename: Unable to allocate %d bytes from nonpaged pool.\n",
|
|
tempUlong,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Release the share root handle if device is removable
|
|
//
|
|
|
|
SrvReleaseShareRootHandle( TargetShare );
|
|
|
|
FREE_HEAP( fileRenameInformation );
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
|
|
}
|
|
|
|
//
|
|
// Get expanded filename
|
|
//
|
|
|
|
status = SrvWildcardRename(
|
|
&targetBaseName,
|
|
&sourceBaseName,
|
|
&newTargetBaseName
|
|
);
|
|
|
|
if ( !NT_SUCCESS( status ) ) {
|
|
|
|
//
|
|
// Release the share root handle if device is removable
|
|
//
|
|
|
|
SrvReleaseShareRootHandle( TargetShare );
|
|
|
|
DEALLOCATE_NONPAGED_POOL( newTargetBaseName.Buffer );
|
|
FREE_HEAP( fileRenameInformation );
|
|
return STATUS_OBJECT_NAME_INVALID;
|
|
|
|
}
|
|
|
|
//
|
|
// tempUlong is equal to the directory path without this filename
|
|
// but including the last delimeter.
|
|
//
|
|
|
|
tempUlong = Target->Length - targetBaseName.Length;
|
|
|
|
//
|
|
// Copy the directory path (including the delimeter.
|
|
//
|
|
|
|
RtlCopyMemory(
|
|
fileRenameInformation->FileName,
|
|
Target->Buffer,
|
|
tempUlong
|
|
);
|
|
|
|
s = (PWCH) ((PCHAR)fileRenameInformation->FileName + tempUlong);
|
|
|
|
//
|
|
// Copy the expanded file name
|
|
//
|
|
|
|
RtlCopyMemory(
|
|
s,
|
|
newTargetBaseName.Buffer,
|
|
newTargetBaseName.Length
|
|
);
|
|
|
|
|
|
fileRenameInformation->FileNameLength = tempUlong +
|
|
newTargetBaseName.Length;
|
|
|
|
DEALLOCATE_NONPAGED_POOL( newTargetBaseName.Buffer );
|
|
|
|
} else {
|
|
|
|
fileRenameInformation->FileNameLength = Target->Length;
|
|
|
|
RtlCopyMemory(
|
|
fileRenameInformation->FileName,
|
|
Target->Buffer,
|
|
Target->Length
|
|
);
|
|
|
|
// Check if we can do a fast rename if they are in the same path (which is usually the case)
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
SrvGetBaseFileName( Target, &targetBaseName );
|
|
|
|
|
|
if ((Source->Length - sourceBaseName.Length) == (Target->Length - targetBaseName.Length)) {
|
|
ULONG i;
|
|
PWCH sptr,tptr;
|
|
|
|
i = Source->Length - sourceBaseName.Length;
|
|
i=i>>1;
|
|
|
|
sptr = &Source->Buffer[i-1];
|
|
tptr = &Target->Buffer[i-1];
|
|
|
|
while ( i > 0) {
|
|
if (*sptr-- != *tptr--) {
|
|
goto no_match;
|
|
}
|
|
i--;
|
|
}
|
|
|
|
// If the names matched, we're set for a quick rename (where the directory is not needed,
|
|
// since they are in the same path)
|
|
fileRenameInformation->RootDirectory = NULL;
|
|
|
|
fileRenameInformation->FileNameLength = targetBaseName.Length;
|
|
|
|
RtlCopyMemory(
|
|
fileRenameInformation->FileName,
|
|
targetBaseName.Buffer,
|
|
targetBaseName.Length
|
|
);
|
|
}
|
|
}
|
|
|
|
no_match:
|
|
|
|
//
|
|
// If we know that the target is a directory, then concatenate the
|
|
// source base name to the end of the target name.
|
|
//
|
|
|
|
if ( *SmbFlags & SMB_TARGET_IS_DIRECTORY ) {
|
|
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
|
|
s = (PWCH)((PCHAR)fileRenameInformation->FileName +
|
|
fileRenameInformation->FileNameLength);
|
|
|
|
//
|
|
// Only add in a directory separator if the target had some path
|
|
// information. This avoids having a new name like "\NAME", which
|
|
// is illegal with a relative rename (there should be no
|
|
// leading backslash).
|
|
//
|
|
|
|
if ( Target->Length > 0 ) {
|
|
*s++ = DIRECTORY_SEPARATOR_CHAR;
|
|
}
|
|
|
|
RtlCopyMemory( s, sourceBaseName.Buffer, sourceBaseName.Length );
|
|
|
|
fileRenameInformation->FileNameLength +=
|
|
sizeof(WCHAR) + sourceBaseName.Length;
|
|
}
|
|
|
|
//
|
|
// Call NtSetInformationFile to actually rename the file.
|
|
//
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
UNICODE_STRING name;
|
|
name.Length = (USHORT)fileRenameInformation->FileNameLength;
|
|
name.Buffer = fileRenameInformation->FileName;
|
|
SrvPrint2( "Renaming %wZ to %wZ\n", Source, &name );
|
|
}
|
|
switch (InformationLevel) {
|
|
case SMB_NT_RENAME_RENAME_FILE:
|
|
NtInformationLevel = FileRenameInformation;
|
|
|
|
//
|
|
// If we are renaming a substream, we do not supply
|
|
// fileRenameInformation->RootDirectory
|
|
//
|
|
es = fileRenameInformation->FileName +
|
|
fileRenameInformation->FileNameLength / sizeof( WCHAR );
|
|
|
|
for( s = fileRenameInformation->FileName; s < es; s++ ) {
|
|
if( *s == L':' ) {
|
|
fileRenameInformation->RootDirectory = 0;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SMB_NT_RENAME_MOVE_CLUSTER_INFO:
|
|
NtInformationLevel = FileMoveClusterInformation;
|
|
break;
|
|
|
|
case SMB_NT_RENAME_SET_LINK_INFO:
|
|
NtInformationLevel = FileLinkInformation;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
status = IMPERSONATE( WorkContext );
|
|
|
|
if( NT_SUCCESS( status ) ) {
|
|
status = NtSetInformationFile(
|
|
SourceHandle,
|
|
&ioStatusBlock,
|
|
fileRenameInformation,
|
|
renameBlockSize,
|
|
NtInformationLevel
|
|
);
|
|
|
|
//
|
|
// If the media was changed and we can come up with a new share root handle,
|
|
// then we should retry the operation
|
|
//
|
|
if( SrvRetryDueToDismount( TargetShare, status ) ) {
|
|
|
|
fileRenameInformation->RootDirectory = TargetShare->RootDirectoryHandle;
|
|
|
|
status = NtSetInformationFile(
|
|
SourceHandle,
|
|
&ioStatusBlock,
|
|
fileRenameInformation,
|
|
renameBlockSize,
|
|
NtInformationLevel
|
|
);
|
|
}
|
|
|
|
REVERT( );
|
|
}
|
|
|
|
if ( NT_SUCCESS(status) ) {
|
|
status = ioStatusBlock.Status;
|
|
SrvRemoveCachedDirectoryName( WorkContext, Source );
|
|
}
|
|
|
|
//
|
|
// If the status was STATUS_OBJECT_NAME_COLLISION then the target
|
|
// already existed as a directory. Unless the target name was
|
|
// supposed to indicate a file or we have already tried used the
|
|
// source name, retry by concatenating the source base name to the
|
|
// target.
|
|
//
|
|
|
|
if ( status == STATUS_OBJECT_NAME_COLLISION &&
|
|
!FailIfTargetIsDirectory &&
|
|
!( *SmbFlags & SMB_TARGET_IS_FILE ) &&
|
|
!( *SmbFlags & SMB_TARGET_IS_DIRECTORY ) ) {
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
SrvPrint0( "Retrying rename with source name.\n" );
|
|
}
|
|
|
|
//
|
|
// Set the flags so that future calls to this routine will do
|
|
// the right thing first time around.
|
|
//
|
|
|
|
*SmbFlags |= SMB_TARGET_IS_DIRECTORY;
|
|
|
|
//
|
|
// Generate the new target name.
|
|
//
|
|
|
|
SrvGetBaseFileName( Source, &sourceBaseName );
|
|
|
|
s = (PWCH)((PCHAR)fileRenameInformation->FileName +
|
|
fileRenameInformation->FileNameLength);
|
|
|
|
*s++ = DIRECTORY_SEPARATOR_CHAR;
|
|
|
|
RtlCopyMemory( s, sourceBaseName.Buffer, sourceBaseName.Length );
|
|
|
|
fileRenameInformation->FileNameLength +=
|
|
sizeof(WCHAR) + sourceBaseName.Length;
|
|
|
|
//
|
|
// Do the rename again. If it fails this time, too bad.
|
|
//
|
|
// *** Note that it may fail because the source and target
|
|
// exist on different volumes. This could potentially
|
|
// cause confusion for DOS clients in the presence of
|
|
// links.
|
|
|
|
IF_SMB_DEBUG(FILE_CONTROL2) {
|
|
UNICODE_STRING name;
|
|
name.Length = (USHORT)fileRenameInformation->FileNameLength;
|
|
name.Buffer = fileRenameInformation->FileName;
|
|
SrvPrint2( "Renaming %wZ to %wZ\n", Source, &name );
|
|
}
|
|
|
|
status = IMPERSONATE( WorkContext );
|
|
|
|
if( NT_SUCCESS( status ) ) {
|
|
status = NtSetInformationFile(
|
|
SourceHandle,
|
|
&ioStatusBlock,
|
|
fileRenameInformation,
|
|
renameBlockSize,
|
|
NtInformationLevel
|
|
);
|
|
|
|
//
|
|
// If the media was changed and we can come up with a new share root handle,
|
|
// then we should retry the operation
|
|
//
|
|
if( SrvRetryDueToDismount( TargetShare, status ) ) {
|
|
|
|
fileRenameInformation->RootDirectory = TargetShare->RootDirectoryHandle;
|
|
|
|
status = NtSetInformationFile(
|
|
SourceHandle,
|
|
&ioStatusBlock,
|
|
fileRenameInformation,
|
|
renameBlockSize,
|
|
NtInformationLevel
|
|
);
|
|
}
|
|
|
|
REVERT( );
|
|
}
|
|
|
|
if ( NT_SUCCESS(status) ) {
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the share root handle if device is removable
|
|
//
|
|
|
|
SrvReleaseShareRootHandle( TargetShare );
|
|
|
|
FREE_HEAP( fileRenameInformation );
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
SrvPrint1( "DoRename: NtSetInformationFile failed, status = %X\n",
|
|
status );
|
|
}
|
|
}
|
|
|
|
return status;
|
|
|
|
} // DoRename
|