archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/base/ntsetup/textmode/cmdcons/expand.c

787 lines
20 KiB
Raw Permalink Blame History

/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
expand.c
Abstract:
This module implements the file expand command.
Author:
Mike Sliger (msliger) 29-Apr-1999
Revision History:
--*/
#include "cmdcons.h"
#pragma hdrstop
//
// structure tunneled thru SpExpandFile to carry info to/from callback
//
typedef struct {
LPWSTR FileSpec;
BOOLEAN DisplayFiles;
BOOLEAN MatchedAnyFiles;
ULONG NumberOfFilesDone;
BOOLEAN UserAborted;
BOOLEAN OverwriteExisting;
} EXPAND_CONTEXT;
BOOLEAN
pRcCheckForBreak( VOID );
EXPAND_CALLBACK_RESULT
pRcExpandCallback(
EXPAND_CALLBACK_MESSAGE Message,
PWSTR FileName,
PLARGE_INTEGER FileSize,
PLARGE_INTEGER FileTime,
ULONG FileAttributes,
PVOID UserData
);
BOOL
pRcPatternMatch(
LPWSTR pszString,
LPWSTR pszPattern,
IN BOOL fImplyDotAtEnd
);
ULONG
RcCmdExpand(
IN PTOKENIZED_LINE TokenizedLine
)
{
PLINE_TOKEN Token;
LPWSTR Arg;
LPWSTR SrcFile = NULL;
LPWSTR DstFile = NULL;
LPWSTR FileSpec = NULL;
LPWSTR SrcNtFile = NULL;
LPWSTR DstNtPath = NULL;
LPWSTR s;
IO_STATUS_BLOCK IoStatusBlock;
UNICODE_STRING UnicodeString;
HANDLE Handle;
OBJECT_ATTRIBUTES Obja;
NTSTATUS Status;
LPWSTR YesNo;
WCHAR Text[3];
IO_STATUS_BLOCK status_block;
FILE_BASIC_INFORMATION fileInfo;
WCHAR * pos;
ULONG CopyFlags = 0;
BOOLEAN DisplayFileList = FALSE;
BOOLEAN OverwriteExisting = NoCopyPrompt;
EXPAND_CONTEXT Context;
ASSERT(TokenizedLine->TokenCount >= 1);
if (RcCmdParseHelp( TokenizedLine, MSG_EXPAND_HELP )) {
goto exit;
}
//
// Parse command line
//
for( Token = TokenizedLine->Tokens->Next;
Token != NULL;
Token = Token->Next ) {
Arg = Token->String;
if(( Arg[0] == L'-' ) || ( Arg[0] == L'/' )) {
switch( Arg[1] ) {
case L'F':
case L'f':
if(( Arg[2] == L':' ) && ( FileSpec == NULL )) {
FileSpec = &Arg[3];
} else {
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
break;
case L'D':
case L'd':
if ( Arg[2] == L'\0' ) {
DisplayFileList = TRUE;
} else {
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
break;
case L'Y':
case L'y':
if ( Arg[2] == L'\0' ) {
OverwriteExisting = TRUE;
} else {
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
break;
default:
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
} else if( SrcFile == NULL ) {
SrcFile = Arg;
} else if( DstFile == NULL ) {
DstFile = SpDupStringW( Arg );
} else {
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
}
if(( SrcFile == NULL ) ||
(( DstFile != NULL ) && ( DisplayFileList == TRUE ))) {
RcMessageOut(MSG_SYNTAX_ERROR);
goto exit;
}
if ( RcDoesPathHaveWildCards( SrcFile )) {
RcMessageOut(MSG_DIR_WILDCARD_NOT_SUPPORTED);
goto exit;
}
//
// Translate the source name to the NT namespace
//
if (!RcFormFullPath( SrcFile, _CmdConsBlock->TemporaryBuffer, TRUE )) {
RcMessageOut(MSG_INVALID_PATH);
goto exit;
}
SrcNtFile = SpDupStringW( _CmdConsBlock->TemporaryBuffer );
if ( !DisplayFileList ) {
BOOLEAN OnRemovableMedia;
//
// Create a destination path name when the user did not
// provide one. We use the current drive and directory.
//
if( DstFile == NULL ) {
RcGetCurrentDriveAndDir( _CmdConsBlock->TemporaryBuffer );
DstFile = SpDupStringW( _CmdConsBlock->TemporaryBuffer );
}
//
// create the destination paths
//
if (!RcFormFullPath( DstFile, _CmdConsBlock->TemporaryBuffer, FALSE )) {
RcMessageOut(MSG_INVALID_PATH);
goto exit;
}
if (!RcIsPathNameAllowed(_CmdConsBlock->TemporaryBuffer,FALSE,FALSE)) {
RcMessageOut(MSG_ACCESS_DENIED);
goto exit;
}
if (!RcFormFullPath( DstFile, _CmdConsBlock->TemporaryBuffer, TRUE )) {
RcMessageOut(MSG_INVALID_PATH);
goto exit;
}
DstNtPath = SpDupStringW( _CmdConsBlock->TemporaryBuffer );
//
// check for removable media
//
Status = RcIsFileOnRemovableMedia(DstNtPath, &OnRemovableMedia);
if (AllowRemovableMedia == FALSE && (!NT_SUCCESS(Status) || OnRemovableMedia)) {
RcMessageOut(MSG_ACCESS_DENIED);
goto exit;
}
}
//
// setup context for callbacks
//
RtlZeroMemory(&Context, sizeof(Context));
Context.FileSpec = FileSpec;
Context.DisplayFiles = DisplayFileList;
Context.OverwriteExisting = OverwriteExisting;
if ( DisplayFileList ) {
pRcEnableMoreMode();
}
Status = SpExpandFile( SrcNtFile, DstNtPath, pRcExpandCallback, &Context );
pRcDisableMoreMode();
if( !NT_SUCCESS(Status) && !Context.UserAborted ) {
RcNtError( Status, MSG_CANT_EXPAND_FILE );
} else if (( Context.NumberOfFilesDone == 0 ) &&
( Context.MatchedAnyFiles == FALSE ) &&
( Context.FileSpec != NULL )) {
RcMessageOut( MSG_EXPAND_NO_MATCH, Context.FileSpec, SrcFile );
}
if ( Context.MatchedAnyFiles ) {
if ( DisplayFileList ) {
RcMessageOut( MSG_EXPAND_SHOWN, Context.NumberOfFilesDone );
} else {
RcMessageOut( MSG_EXPAND_COUNT, Context.NumberOfFilesDone );
}
}
exit:
if( SrcNtFile ) {
SpMemFree( SrcNtFile );
}
if( DstFile ) {
SpMemFree( DstFile );
}
if( DstNtPath ) {
SpMemFree( DstNtPath );
}
return 1;
}
EXPAND_CALLBACK_RESULT
pRcExpandCallback(
EXPAND_CALLBACK_MESSAGE Message,
PWSTR FileName,
PLARGE_INTEGER FileSize,
PLARGE_INTEGER FileTime,
ULONG FileAttributes,
PVOID UserData
)
{
EXPAND_CONTEXT * Context = (EXPAND_CONTEXT * ) UserData;
LPWSTR YesNo;
EXPAND_CALLBACK_RESULT rc;
WCHAR Text[3];
switch ( Message )
{
case EXPAND_COPY_FILE:
//
// Watch for Ctl-C or ESC while processing
//
if ( pRcCheckForBreak() ) {
Context->UserAborted = TRUE;
return( EXPAND_ABORT );
}
//
// See if filename matches filespec pattern, if any
//
if ( Context->FileSpec != NULL ) {
//
// To be "*.*"-friendly, we need to know if there is a real
// dot in the last element of the string to be matched
//
BOOL fAllowImpliedDot = TRUE;
LPWSTR p;
for ( p = FileName; *p != L'\0'; p++ ) {
if ( *p == L'.' ) {
fAllowImpliedDot = FALSE;
} else if ( *p == L'\\' ) {
fAllowImpliedDot = TRUE;
}
}
if ( !pRcPatternMatch( FileName,
Context->FileSpec,
fAllowImpliedDot )) {
//
// File doesn't match given spec: skip it
//
return( EXPAND_SKIP_THIS_FILE );
}
}
Context->MatchedAnyFiles = TRUE; // don't report "no matches"
if ( Context->DisplayFiles ) {
//
// We're just listing file names, and we must do it now, because
// we're going to tell ExpandFile to skip this one, so this will
// be the last we here about it.
//
WCHAR LineOut[50];
WCHAR *p;
//
// Format the date and time, which go first.
//
RcFormatDateTime(FileTime,LineOut);
RcTextOut(LineOut);
//
// 2 spaces for separation
//
RcTextOut(L" ");
//
// File attributes.
//
p = LineOut;
*p++ = L'-';
if(FileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
*p++ = L'a';
} else {
*p++ = L'-';
}
if(FileAttributes & FILE_ATTRIBUTE_READONLY) {
*p++ = L'r';
} else {
*p++ = L'-';
}
if(FileAttributes & FILE_ATTRIBUTE_HIDDEN) {
*p++ = L'h';
} else {
*p++ = L'-';
}
if(FileAttributes & FILE_ATTRIBUTE_SYSTEM) {
*p++ = L's';
} else {
*p++ = L'-';
}
*p++ = L'-';
*p++ = L'-';
*p++ = L'-';
*p = 0;
RcTextOut(LineOut);
//
// 2 spaces for separation
//
RcTextOut(L" ");
//
// Now, put the size in there. Right justified and space padded
// up to 8 chars. Otherwise unjustified or padded.
//
RcFormat64BitIntForOutput(FileSize->QuadPart,LineOut,TRUE);
if(FileSize->QuadPart > 99999999i64) {
RcTextOut(LineOut);
} else {
RcTextOut(LineOut+11); // outputs 8 chars
}
RcTextOut(L" ");
//
// Finally, put the filename on the line.
//
if( !RcTextOut( FileName ) || !RcTextOut( L"\r\n" )) {
Context->UserAborted = TRUE;
return( EXPAND_ABORT ); /* user aborted display output */
}
Context->NumberOfFilesDone++;
return( EXPAND_SKIP_THIS_FILE );
} // end if DisplayFiles
//
// This file qualified, and we're not just displaying, so tell
// ExpandFile to do it.
//
return( EXPAND_COPY_THIS_FILE );
case EXPAND_COPIED_FILE:
//
// Notification that a file has been copied successfully.
//
RcMessageOut( MSG_EXPANDED, FileName);
Context->NumberOfFilesDone++;
return( EXPAND_NO_ERROR );
case EXPAND_QUERY_OVERWRITE:
//
// Query for approval to overwrite an existing file.
//
if ( Context->OverwriteExisting ) {
return( EXPAND_COPY_THIS_FILE );
}
rc = EXPAND_SKIP_THIS_FILE;
YesNo = SpRetreiveMessageText( ImageBase, MSG_YESNOALLQUIT, NULL, 0 );
if ( YesNo ) {
RcMessageOut( MSG_COPY_OVERWRITE_QUIT, FileName );
if( RcLineIn( Text, 2 ) ) {
if (( Text[0] == YesNo[2] ) || ( Text[0] == YesNo[3] )) {
//
// Yes, we may overwrite this file
//
rc = EXPAND_COPY_THIS_FILE;
} else if (( Text[0] == YesNo[4] ) || ( Text[0] == YesNo[5] )) {
//
// All, we may overwrite this file, and don't prompt again
//
Context->OverwriteExisting = TRUE;
rc = EXPAND_COPY_THIS_FILE;
} else if (( Text[0] == YesNo[6] ) || ( Text[0] == YesNo[7] )) {
//
// No, and stop too.
//
Context->UserAborted = TRUE;
rc = EXPAND_ABORT;
}
}
SpMemFree( YesNo );
}
return( rc );
case EXPAND_NOTIFY_MULTIPLE:
//
// We're being advised that the source contains multiple files.
// If we don't have a selective filespec, we'll abort.
//
if ( Context->FileSpec == NULL ) {
RcMessageOut( MSG_FILESPEC_REQUIRED );
Context->UserAborted = TRUE;
return ( EXPAND_ABORT );
}
return ( EXPAND_CONTINUE );
case EXPAND_NOTIFY_CANNOT_EXPAND:
//
// We're being advised that the source file format is not
// recognized. We display the file name and abort.
//
RcMessageOut( MSG_CANT_EXPAND_FILE, FileName );
Context->UserAborted = TRUE;
return ( EXPAND_ABORT );
case EXPAND_NOTIFY_CREATE_FAILED:
//
// We're being advised that the current target file cannot be
// created. We display the file name and abort.
//
RcMessageOut( MSG_EXPAND_FAILED, FileName );
Context->UserAborted = TRUE;
return ( EXPAND_ABORT );
default:
//
// Ignore any unexpected callback.
//
return( EXPAND_NO_ERROR );
}
}
BOOLEAN
pRcCheckForBreak( VOID )
{
while ( SpInputIsKeyWaiting() ) {
ULONG Key = SpInputGetKeypress();
switch ( Key ) {
case ASCI_ETX:
case ASCI_ESC:
RcMessageOut( MSG_BREAK );
return TRUE;
default:
break;
}
}
return FALSE;
}
//
// pRcPatternMatch() & helpers
//
#define WILDCARD L'*' /* zero or more of any character */
#define WILDCHAR L'?' /* one of any character (does not match END) */
#define END L'\0' /* terminal character */
#define DOT L'.' /* may be implied at end ("hosts" matches "*.") */
static int __inline Lower(c)
{
if ((c >= L'A') && (c <= L'Z'))
{
return(c + (L'a' - L'A'));
}
else
{
return(c);
}
}
static int __inline CharacterMatch(WCHAR chCharacter, WCHAR chPattern)
{
if (Lower(chCharacter) == Lower(chPattern))
{
return(TRUE);
}
else
{
return(FALSE);
}
}
BOOL
pRcPatternMatch(
LPWSTR pszString,
LPWSTR pszPattern,
IN BOOL fImplyDotAtEnd
)
{
/* RECURSIVE */
//
// This function does not deal with 8.3 conventions which might
// be expected for filename comparisons. (In an 8.3 environment,
// "alongfilename.html" would match "alongfil.htm")
//
// This code is NOT MBCS-enabled
//
for ( ; ; )
{
switch (*pszPattern)
{
case END:
//
// Reached end of pattern, so we're done. Matched if
// end of string, no match if more string remains.
//
return(*pszString == END);
case WILDCHAR:
//
// Next in pattern is a wild character, which matches
// anything except end of string. If we reach the end
// of the string, the implied DOT would also match.
//
if (*pszString == END)
{
if (fImplyDotAtEnd == TRUE)
{
fImplyDotAtEnd = FALSE;
}
else
{
return(FALSE);
}
}
else
{
pszString++;
}
pszPattern++;
break;
case WILDCARD:
//
// Next in pattern is a wildcard, which matches anything.
// Find the required character that follows the wildcard,
// and search the string for it. At each occurence of the
// required character, try to match the remaining pattern.
//
// There are numerous equivalent patterns in which multiple
// WILDCARD and WILDCHAR are adjacent. We deal with these
// before our search for the required character.
//
// Each WILDCHAR burns one non-END from the string. An END
// means we have a match. Additional WILDCARDs are ignored.
//
for ( ; ; )
{
pszPattern++;
if (*pszPattern == END)
{
return(TRUE);
}
else if (*pszPattern == WILDCHAR)
{
if (*pszString == END)
{
if (fImplyDotAtEnd == TRUE)
{
fImplyDotAtEnd = FALSE;
}
else
{
return(FALSE);
}
}
else
{
pszString++;
}
}
else if (*pszPattern != WILDCARD)
{
break;
}
}
//
// Now we have a regular character to search the string for.
//
while (*pszString != END)
{
//
// For each match, use recursion to see if the remainder
// of the pattern accepts the remainder of the string.
// If it does not, continue looking for other matches.
//
if (CharacterMatch(*pszString, *pszPattern) == TRUE)
{
if (pRcPatternMatch(pszString + 1, pszPattern + 1, fImplyDotAtEnd) == TRUE)
{
return(TRUE);
}
}
pszString++;
}
//
// Reached end of string without finding required character
// which followed the WILDCARD. If the required character
// is a DOT, consider matching the implied DOT.
//
// Since the remaining string is empty, the only pattern which
// could match after the DOT would be zero or more WILDCARDs,
// so don't bother with recursion.
//
if ((*pszPattern == DOT) && (fImplyDotAtEnd == TRUE))
{
pszPattern++;
while (*pszPattern != END)
{
if (*pszPattern != WILDCARD)
{
return(FALSE);
}
pszPattern++;
}
return(TRUE);
}
//
// Reached end of the string without finding required character.
//
return(FALSE);
break;
default:
//
// Nothing special about the pattern character, so it
// must match source character.
//
if (CharacterMatch(*pszString, *pszPattern) == FALSE)
{
if ((*pszPattern == DOT) &&
(*pszString == END) &&
(fImplyDotAtEnd == TRUE))
{
fImplyDotAtEnd = FALSE;
}
else
{
return(FALSE);
}
}
if (*pszString != END)
{
pszString++;
}
pszPattern++;
}
}
}