Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

662 lines
18 KiB

/*++
Copyright (c) 1988-1999 Microsoft Corporation
Module Name:
cpath.c
Abstract:
Path-related commands
--*/
#include "cmd.h"
extern TCHAR SwitChar, PathChar;
extern TCHAR Fmt17[] ;
extern TCHAR CurDrvDir[] ;
extern int LastRetCode ; /* @@ */
extern TCHAR TmpBuf[] ;
/**************** START OF SPECIFICATIONS ***********************/
/* */
/* SUBROUTINE NAME: eMkDir */
/* */
/* DESCRIPTIVE NAME: Begin execution of the MKDIR command */
/* */
/* FUNCTION: This routine will make any number of directories, */
/* and will continue if it encounters a bad argument. */
/* eMkDir will be called if the user enters MD or */
/* MKDIR on the command line. */
/* */
/* NOTES: */
/* */
/* ENTRY POINT: eMkDir */
/* LINKAGE: Near */
/* */
/* INPUT: n - parse tree node containing the MKDIR command */
/* */
/* EXIT-NORMAL: returns SUCCESS if all directories were */
/* successfully created. */
/* */
/* EXIT-ERROR: returns FAILURE otherwise */
/* */
/* EFFECTS: None. */
/* */
/* INTERNAL REFERENCES: */
/* ROUTINES: */
/* LoopThroughArgs - break up command line, call MdWork */
/* */
/* EXTERNAL REFERENCES: */
/* ROUTINES: */
/* */
/**************** END OF SPECIFICATIONS *************************/
int eMkdir(n)
struct cmdnode *n ;
{
DEBUG((PCGRP, MDLVL, "MKDIR: Entered.")) ;
return(LastRetCode = LoopThroughArgs(n->argptr, MdWork, LTA_CONT)) ;
}
/**************** START OF SPECIFICATIONS ***********************/
/* */
/* SUBROUTINE NAME: MdWork */
/* */
/* DESCRIPTIVE NAME: Make a directory */
/* */
/* FUNCTION: MdWork creates a new directory. */
/* */
/* NOTES: */
/* */
/* ENTRY POINT: MdWork */
/* LINKAGE: Near */
/* */
/* INPUT: arg - a pointer to a NULL terminated string of the */
/* new directory to create. */
/* */
/* EXIT-NORMAL: returns SUCCESS if the directory is made */
/* successfully */
/* */
/* EXIT-ERROR: returns FAILURE otherwise */
/* */
/* EFFECTS: None. */
/* */
/* INTERNAL REFERENCES: */
/* ROUTINES: */
/* PutStdErr - Writes to standard error */
/* */
/* EXTERNAL REFERENCES: */
/* ROUTINES: */
/* DOSMKDIR */
/* */
/**************** END OF SPECIFICATIONS *************************/
int MdWork(arg)
TCHAR *arg ;
{
ULONG Status;
TCHAR *lpw;
TCHAR TempBuffer[MAX_PATH];
DWORD Length;
/* Check if drive is valid because Dosmkdir does not
return invalid drive @@5 */
if ((arg[1] == COLON) && !IsValidDrv(*arg)) {
PutStdErr(ERROR_INVALID_DRIVE, NOARGS);
return(FAILURE) ;
}
Length = GetFullPathName(arg, MAX_PATH, TempBuffer, &lpw);
if (Length == 0) {
PutStdErr( GetLastError(), NOARGS);
return FAILURE;
}
if (Length >= MAX_PATH) {
PutStdErr( MSG_FULL_PATH_TOO_LONG, ONEARG, arg );
return FAILURE;
}
if (CreateDirectory( arg, NULL )) {
return SUCCESS;
}
Status = GetLastError();
if (Status == ERROR_ALREADY_EXISTS) {
PutStdErr( MSG_DIR_EXISTS, ONEARG, arg );
return FAILURE;
} else if (Status != ERROR_PATH_NOT_FOUND) {
PutStdErr( Status, NOARGS);
return FAILURE;
}
//
// If no extensions, then simply fail.
//
if (!fEnableExtensions) {
PutStdErr(ERROR_CANNOT_MAKE, NOARGS);
return FAILURE;
}
//
// loop over input path and create any needed intermediary directories.
//
// Find the point in the string to begin the creation. Note, for UNC
// names, we must skip the machine and the share
//
if (TempBuffer[1] == COLON) {
//
// Skip D:\
//
lpw = TempBuffer+3;
} else if (TempBuffer[0] == BSLASH && TempBuffer[1] == BSLASH) {
//
// Skip \\server\share\
//
lpw = TempBuffer+2;
while (*lpw && *lpw != BSLASH) {
lpw++;
}
if (*lpw) {
lpw++;
}
while (*lpw && *lpw != BSLASH) {
lpw++;
}
if (*lpw) {
lpw++;
}
} else {
//
// For some reason, GetFullPath has given us something we can't understand
//
PutStdErr(ERROR_CANNOT_MAKE, NOARGS);
return FAILURE;
}
//
// Walk through the components creating them
//
while (*lpw) {
//
// Move forward until the next path separator
//
while (*lpw && *lpw != BSLASH) {
lpw++;
}
//
// If we've encountered a path character, then attempt to
// make the given path.
//
if (*lpw == BSLASH) {
*lpw = NULLC;
if (!CreateDirectory( TempBuffer, NULL )) {
Status = GetLastError();
if (Status != ERROR_ALREADY_EXISTS) {
PutStdErr( ERROR_CANNOT_MAKE, NOARGS );
return FAILURE;
}
}
*lpw++ = BSLASH;
}
}
if (!CreateDirectory( TempBuffer, NULL )) {
Status = GetLastError( );
if (Status != ERROR_ALREADY_EXISTS) {
PutStdErr( Status, NOARGS);
return FAILURE;
}
}
return(SUCCESS);
}
/*** eChdir - execute the Chdir command
*
* Purpose:
* If the command is "cd", display the current directory of the current
* drive.
*
* If the command is "cd d:", display the current directory of drive d.
*
* If the command is "cd str", change the current directory to str.
*
* int eChdir(struct cmdnode *n)
*
* Args:
* n - the parse tree node containing the chdir command
*
* Returns:
* SUCCESS if the requested task was accomplished.
* FAILURE if it was not.
*
*/
int eChdir(n)
struct cmdnode *n ;
{
TCHAR *tas, *src, *dst; /* Tokenized arg string */
TCHAR dirstr[MAX_PATH] ;/* Holds current dir of specified drive */
//
// If extensions are enabled, dont treat spaces as delimeters so it is
// easier to CHDIR to directory names with embedded spaces without having
// to quote the directory name
//
tas = TokStr(n->argptr, TEXT( "" ), fEnableExtensions ? TS_WSPACE|TS_SDTOKENS : TS_SDTOKENS) ;
if (fEnableExtensions) {
//
// If extensions were enabled we could have some trailing spaces
// that need to be nuked since there weren't treated as delimeters
// by TokStr call above.
//
// We compress the extra spaces out since we rely on the tokenized
// format later inside ChdirWork
//
src = tas;
dst = tas;
while (*src) {
while (*dst = *src++)
dst += 1;
while (_istspace(dst[-1]))
dst -= 1;
*dst++ = NULLC;
}
*dst = NULLC;
}
DEBUG((PCGRP, CDLVL, "CHDIR: tas = `%ws'", tas)) ;
mystrcpy( tas, StripQuotes( tas ) );
//
// No arguments means display current drive and directory
//
if (*tas == NULLC) {
GetDir(CurDrvDir, GD_DEFAULT) ;
cmd_printf(Fmt17, CurDrvDir) ;
} else
//
// single drive letter means display current dirctory on that drive
//
if (mystrlen(tas) == 2 && *(tas+1) == COLON && _istalpha(*tas)) {
GetDir(dirstr, *tas) ;
cmd_printf(Fmt17, dirstr) ;
} else
//
// We need to change current directory (and possibly drive)
//
{
return( LastRetCode = ChdirWork(tas) );
}
return( LastRetCode = SUCCESS );
}
int ChdirWork( TCHAR *tas )
{
unsigned i = MSG_BAD_SYNTAX;
//
// If there's no leading "/D", just chdir
// to the input path
//
if (_tcsnicmp( tas, TEXT( "/D" ), 2)) {
i = ChangeDir((TCHAR *)tas);
} else {
//
// Advance over the "/D" and intervening whitespace
//
tas = SkipWhiteSpace( tas + 2 );
//
// if there's no other switch char, strip any quotes and do
// the chdir
//
if (*tas != SwitChar) {
_tcscpy( tas, StripQuotes( tas ));
i = ChangeDir2(tas, TRUE);
}
}
if (i != SUCCESS) {
PutStdErr( i, ONEARG, tas);
return (FAILURE) ;
}
return (SUCCESS) ;
}
#define SIZEOFSTACK 25
typedef struct {
PTCHAR SavedDirectory;
TCHAR NetDriveCreated;
} *PSAVEDDIRECTORY;
PSAVEDDIRECTORY SavedDirectoryStack = NULL;
int StrStackDepth = 0;
int MaxStackDepth = 0;
int GetDirStackDepth(void)
{
return StrStackDepth;
}
int
PushStr ( PTCHAR pszString )
{
//
// If we're full, grow the stack by an increment
//
if (StrStackDepth == MaxStackDepth) {
PSAVEDDIRECTORY Tmp =
realloc( SavedDirectoryStack,
sizeof( *SavedDirectoryStack ) * (MaxStackDepth + SIZEOFSTACK));
if (Tmp == NULL) {
return FALSE;
}
SavedDirectoryStack = Tmp;
MaxStackDepth += SIZEOFSTACK;
}
SavedDirectoryStack[ StrStackDepth ].SavedDirectory = pszString;
SavedDirectoryStack[ StrStackDepth ].NetDriveCreated = NULLC;
StrStackDepth += 1;
return TRUE;
}
PTCHAR
PopStr ()
{
PTCHAR pszString;
if (StrStackDepth == 0) {
return ( NULL );
}
StrStackDepth -= 1;
pszString = SavedDirectoryStack[StrStackDepth].SavedDirectory;
if (SavedDirectoryStack[StrStackDepth].NetDriveCreated != NULLC) {
TCHAR szLocalName[4];
szLocalName[0] = SavedDirectoryStack[StrStackDepth].NetDriveCreated;
szLocalName[1] = COLON;
szLocalName[2] = NULLC;
SavedDirectoryStack[StrStackDepth].NetDriveCreated = NULLC;
try {
WNetCancelConnection2(szLocalName, 0, TRUE);
} except (EXCEPTION_EXECUTE_HANDLER) {
}
}
SavedDirectoryStack[StrStackDepth].SavedDirectory = NULL;
//
// If we can eliminate an increment from the stack, go do so
//
if (StrStackDepth > 0 && StrStackDepth + 2 * SIZEOFSTACK <= MaxStackDepth) {
PSAVEDDIRECTORY Tmp =
realloc( SavedDirectoryStack,
sizeof( *SavedDirectoryStack ) * (StrStackDepth + SIZEOFSTACK));
if (Tmp != NULL) {
SavedDirectoryStack = Tmp;
MaxStackDepth = StrStackDepth + SIZEOFSTACK;
}
}
return ( pszString );
}
VOID
DumpStrStack() {
int i;
for (i=StrStackDepth-1; i>=0; i--) {
cmd_printf( Fmt17, SavedDirectoryStack[i].SavedDirectory );
}
return;
}
BOOLEAN
PushCurDir()
{
PTCHAR pszCurDir;
GetDir( CurDrvDir, GD_DEFAULT ) ;
if ((pszCurDir=HeapAlloc( GetProcessHeap( ), 0, (mystrlen( CurDrvDir )+1)*sizeof( TCHAR ))) != NULL) {
mystrcpy( pszCurDir, CurDrvDir) ;
if (PushStr( pszCurDir ))
return ( TRUE );
HeapFree( GetProcessHeap( ), 0, pszCurDir );
}
return ( FALSE );
}
int ePushDir(n)
struct cmdnode *n ;
{
TCHAR *tas ; /* Tokenized arg string */
PTCHAR pszTmp, s;
//
// If extensions are enabled, dont treat spaces as delimeters so it is
// easier to CHDIR to directory names with embedded spaces without having
// to quote the directory name
//
tas = TokStr(n->argptr, NULL, fEnableExtensions ? TS_WSPACE|TS_NOFLAGS : TS_NOFLAGS) ;
if (fEnableExtensions) {
//
// If extensions were enabled we could have some trailing spaces
// that need to be nuked since there weren't treated as delimeters
// by TokStr call above.
//
s = lastc(tas);
while (s > tas) {
if (_istspace(*s))
*s-- = NULLC;
else
break;
}
}
mystrcpy(tas, StripQuotes(tas) );
LastRetCode = SUCCESS;
if (*tas == NULLC) {
//
// Print out entire stack
//
DumpStrStack();
} else if (PushCurDir()) {
//
// If extensions are enabled and a UNC name was given, then do
// a temporary NET USE to define a drive letter that we can
// use to change drive/directory to. The matching POPD will
// delete the temporary drive letter.
//
if (fEnableExtensions && tas[0] == BSLASH && tas[1] == BSLASH) {
NETRESOURCE netResource;
TCHAR szLocalName[4];
PTCHAR s;
//
// If there is a directory specified after the \\server\share
// then test to see if that directory exists before doing any
// network connections
//
if ((s = _tcschr(&tas[2], BSLASH)) != NULL
&& (s = _tcschr(s+1, BSLASH)) != NULL) {
if (GetFileAttributes( tas ) == -1) {
LastRetCode = GetLastError( );
if (LastRetCode == ERROR_FILE_NOT_FOUND) {
LastRetCode = ERROR_PATH_NOT_FOUND;
}
} else {
*s++ = NULLC;
}
}
szLocalName[0] = TEXT('Z');
szLocalName[1] = COLON;
szLocalName[2] = NULLC;
netResource.dwType = RESOURCETYPE_DISK;
netResource.lpLocalName = szLocalName;
netResource.lpRemoteName = tas;
netResource.lpProvider = NULL;
while (LastRetCode == NO_ERROR && szLocalName[0] != TEXT('A')) {
try {
LastRetCode = WNetAddConnection2( &netResource, NULL, NULL, 0);
} except (LastRetCode = GetExceptionCode( ), EXCEPTION_EXECUTE_HANDLER) {
}
switch (LastRetCode) {
case NO_ERROR:
SavedDirectoryStack[StrStackDepth-1].NetDriveCreated = szLocalName[0];
tas[0] = szLocalName[0];
tas[1] = szLocalName[1];
tas[2] = BSLASH;
if (s != NULL)
_tcscpy(&tas[3], s);
else
tas[3] = NULLC;
goto godrive;
case ERROR_ALREADY_ASSIGNED:
case ERROR_DEVICE_ALREADY_REMEMBERED:
szLocalName[0] = (TCHAR)((UCHAR)szLocalName[0] - 1);
LastRetCode = NO_ERROR;
break;
default:
break;
}
}
godrive: ;
}
//
// The NET USE succeeded, now attempt to change the directory
// as well.
//
if (LastRetCode == NO_ERROR
&& (LastRetCode = ChangeDir2( tas, TRUE )) == SUCCESS) {
if (tas[1] == ':') {
GetDir(CurDrvDir,tas[0]);
}
}
if (LastRetCode != SUCCESS) {
pszTmp = PopStr();
HeapFree(GetProcessHeap(), 0, pszTmp);
PutStdErr( LastRetCode, NOARGS );
LastRetCode = FAILURE;
}
} else {
PutStdErr( MSG_ERROR_PUSHD_DEPTH_EXCEEDED, NOARGS );
LastRetCode = FAILURE;
}
return ( LastRetCode );
}
int ePopDir(n)
struct cmdnode *n ;
{
PTCHAR pszCurDir;
UNREFERENCED_PARAMETER( n );
if (pszCurDir = PopStr()) {
if (ChangeDir2( pszCurDir,TRUE ) == SUCCESS) {
HeapFree(GetProcessHeap(), 0, pszCurDir);
return( SUCCESS );
}
HeapFree(GetProcessHeap(), 0, pszCurDir);
}
return( FAILURE );
}
/*** eRmdir - begin the execution of the Rmdir command
*
* Purpose:
* To remove an arbitrary number of directories.
*
* int eRmdir(struct cmdnode *n)
*
* Args:
* n - the parse tree node containing the rmdir command
*
* Returns:
* SUCCESS if all directories were removed.
* FAILURE if they weren't.
*
*/
int eRmdir(n)
struct cmdnode *n ;
{
DEBUG((PCGRP, RDLVL, "RMDIR: Entered.")) ;
return(RdWork(n->argptr)); // in del.c
}