internal.c File Reference

#include "precomp.h"

Include dependency graph for internal.c:

Go to the source code of this file.

Functions
INT	GetRootPath (IN LPCTSTR InPath, OUT LPTSTR OutPath, IN INT size)
BOOL	SetRootPath (TCHAR *oldpath, TCHAR *InPath)
INT	cmd_chdir (LPTSTR param)
BOOL	MakeFullPath (TCHAR *DirPath)
INT	cmd_mkdir (LPTSTR param)
BOOL	DeleteFolder (LPTSTR Directory)
INT	cmd_rmdir (LPTSTR param)
INT	CommandExit (LPTSTR param)
INT	CommandRem (LPTSTR param)
INT	CommandShowCommands (LPTSTR param)

Function Documentation

cmd_chdir()

INT cmd_chdir

(

LPTSTR

param

)

Definition at line 240 of file internal.c.

{
    BOOL bChangeDrive = FALSE;
    LPTSTR tmp;
    TCHAR szCurrent[MAX_PATH];
 
    /* Filter out special cases first */
 
    /* Print help */
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_CD_HELP);
        return 0;
    }
 
    //
    // FIXME: Use the split() tokenizer if bEnableExtensions == FALSE,
    // so as to cut the parameter at the first separator (space, ',', ';'):
    // - When bEnableExtensions == FALSE, doing
    //   CD system32;winsxs
    //   will go into system32, (but: CD "system32;winsxs" will fail as below), while
    // - When bEnableExtensions == TRUE, it will fail because the "system32;winsxs"
    //   directory does not exist.
    //
 
    /* Remove extra quotes */
    StripQuotes(param);
 
    if (bEnableExtensions)
    {
        /* Strip trailing whitespace */
        tmp = param + _tcslen(param) - 1;
        while (tmp > param && _istspace(*tmp))
            --tmp;
        *(tmp + 1) = _T('\0');
    }
 
    /* Reset the error level */
    nErrorLevel = 0;
 
    /* Print the current directory on a disk */
    if (_tcslen(param) == 2 && param[1] == _T(':'))
    {
        if (GetRootPath(param, szCurrent, ARRAYSIZE(szCurrent)))
        {
            error_invalid_drive();
            return 1;
        }
        ConOutPrintf(_T("%s\n"), szCurrent);
        return 0;
    }
 
    /* Get the current directory */
    GetCurrentDirectory(ARRAYSIZE(szCurrent), szCurrent);
    if (param[0] == _T('\0'))
    {
        ConOutPrintf(_T("%s\n"), szCurrent);
        return 0;
    }
 
    /* If the input string is prefixed with the /D switch, change the drive */
    if (!_tcsncicmp(param, _T("/D"), 2))
    {
        bChangeDrive = TRUE;
        param += 2;
        while (_istspace(*param))
            ++param;
    }
 
    if (!SetRootPath(bChangeDrive ? NULL : szCurrent, param))
    {
        nErrorLevel = 1;
        return 1;
    }
 
    return 0;
}

cmd_mkdir()

INT cmd_mkdir

(

LPTSTR

param

)

Definition at line 360 of file internal.c.

{
    LPTSTR *p;
    INT argc, i;
    DWORD dwLastError;
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_MKDIR_HELP);
        return 0;
    }
 
    p = split (param, &argc, FALSE, FALSE);
    if (argc == 0)
    {
        ConErrResPuts(STRING_ERROR_REQ_PARAM_MISSING);
        freep(p);
        nErrorLevel = 1;
        return 1;
    }
 
    nErrorLevel = 0;
    for (i = 0; i < argc; i++)
    {
        if (!MakeFullPath(p[i]))
        {
            dwLastError = GetLastError();
            switch (dwLastError)
            {
            case ERROR_PATH_NOT_FOUND:
                ConErrResPuts(STRING_MD_ERROR2);
                break;
 
            case ERROR_FILE_EXISTS:
            case ERROR_ALREADY_EXISTS:
                ConErrResPrintf(STRING_MD_ERROR, p[i]);
                break;
 
            default:
                ErrorMessage(GetLastError(), NULL);
            }
            nErrorLevel = 1;
        }
    }
 
    freep (p);
    return nErrorLevel;
}

cmd_rmdir()

INT cmd_rmdir

(

LPTSTR

param

)

Definition at line 521 of file internal.c.

{
    INT nError = 0;
    INT res;
    LPTSTR *arg;
    INT args;
    INT dirCount;
    INT i;
    TCHAR ch;
    BOOL bRecurseDir = FALSE;
    BOOL bQuiet = FALSE;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_RMDIR_HELP);
        return 0;
    }
 
    arg = split(param, &args, FALSE, FALSE);
    dirCount = 0;
 
    /* Check for options anywhere in command line */
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))
        {
            /* Found an option, but check to make sure it has something after it */
            if (_tcslen(arg[i]) == 2)
            {
                ch = _totupper(arg[i][1]);
 
                if (ch == _T('S'))
                    bRecurseDir = TRUE;
                else if (ch == _T('Q'))
                    bQuiet = TRUE;
            }
        }
        else
        {
            dirCount++;
        }
    }
 
    if (dirCount == 0)
    {
        /* No folder to remove */
        error_req_param_missing();
        freep(arg);
        return 1;
    }
 
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))
            continue;
 
        if (bRecurseDir)
        {
            /* Ask the user whether to delete everything in the folder */
            if (!bQuiet)
            {
                res = FilePromptYNA(STRING_DEL_HELP2);
                if (res == PROMPT_NO || res == PROMPT_BREAK)
                {
                    nError = 1;
                    continue;
                }
                if (res == PROMPT_ALL)
                    bQuiet = TRUE;
            }
 
            res = DeleteFolder(arg[i]);
        }
        else
        {
            /* Without /S, do not force directory deletion even if it's read-only */
            res = RemoveDirectory(arg[i]);
        }
 
        if (!res)
        {
            /* Couldn't delete the folder, print out the error */
            nError = GetLastError();
            ErrorMessage(nError, NULL);
        }
    }
 
    freep(arg);
    return nError;
}

CommandExit()

INT CommandExit

(

LPTSTR

param

)

Definition at line 621 of file internal.c.

{
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_EXIT_HELP);
 
        /* Just make sure we don't exit */
        bExit = FALSE;
        return 0;
    }
 
    if (_tcsnicmp(param, _T("/B"), 2) == 0)
    {
        param += 2;
 
        /*
         * If a current batch file is running, exit it,
         * otherwise exit this command interpreter instance.
         */
        if (bc)
        {
            /* Windows' CMD compatibility: Use GOTO :EOF */
            TCHAR EofLabel[] = _T(":EOF");
 
#ifdef SUPPORT_EXIT_B_NO_EXTENSIONS
            /*
             * Temporarily enable extensions so as to support :EOF.
             *
             * Our GOTO implementation ensures that, when extensions are
             * enabled and the label is ':EOF', no immediate change of batch
             * context (done e.g. via ExitBatch() calls) is performed.
             * This will therefore ensure that we do not spoil the extensions
             * state when we restore it below.
             */
            BOOL bOldEnableExtensions = bEnableExtensions;
            bEnableExtensions = TRUE;
#endif
 
            cmd_goto(EofLabel);
 
#ifdef SUPPORT_EXIT_B_NO_EXTENSIONS
            /* Restore the original state of the extensions */
            bEnableExtensions = bOldEnableExtensions;
#endif
        }
        else
        {
            bExit = TRUE;
        }
    }
    else
    {
        /* Exit this command interpreter instance */
        bExit = TRUE;
    }
 
    /* Search for an optional exit code */
    while (_istspace(*param))
        ++param;
 
    /* Set the errorlevel to the exit code */
    if (_istdigit(*param))
    {
        nErrorLevel = _ttoi(param);
        // if (fSingleCommand == 1) return nErrorLevel;
    }
 
    return (bExit ? nErrorLevel : 0);
}

CommandRem()

INT CommandRem

(

LPTSTR

param

)

Definition at line 695 of file internal.c.

{
    if (_tcsstr(param, _T("/?")) == param)
    {
        ConOutResPaging(TRUE,STRING_REM_HELP);
    }
 
    return 0;
}

CommandShowCommands()

INT CommandShowCommands

(

LPTSTR

param

)

Definition at line 707 of file internal.c.

{
    PrintCommandList();
    return 0;
}

DeleteFolder()

BOOL DeleteFolder

(

LPTSTR

Directory

)

Definition at line 414 of file internal.c.

{
    LPTSTR pFileName;
    HANDLE hFile;
    WIN32_FIND_DATA f;
    DWORD dwAttribs;
    TCHAR szFullPath[MAX_PATH];
 
    _tcscpy(szFullPath, Directory);
    pFileName = &szFullPath[_tcslen(szFullPath)];
    /*
     * Append a path separator if we don't have one already, and if this a drive root
     * path is not specified (paths like "C:" mean the current directory on drive C:).
     */
    if (*szFullPath && *(pFileName - 1) != _T(':') && *(pFileName - 1) != _T('\\'))
        *pFileName++ = _T('\\');
    _tcscpy(pFileName, _T("*"));
 
    hFile = FindFirstFile(szFullPath, &f);
    if (hFile != INVALID_HANDLE_VALUE)
    {
        do
        {
            /* Check Breaker */
            if (bCtrlBreak)
                break;
 
            if (!_tcscmp(f.cFileName, _T(".")) ||
                !_tcscmp(f.cFileName, _T("..")))
            {
                continue;
            }
 
            _tcscpy(pFileName, f.cFileName);
 
            dwAttribs = f.dwFileAttributes;
 
            if (dwAttribs & FILE_ATTRIBUTE_DIRECTORY)
            {
                if (!DeleteFolder(szFullPath))
                {
                    /* Couldn't delete the file, print out the error */
                    ErrorMessage(GetLastError(), szFullPath);
 
                    /* Continue deleting files/subfolders */
                }
            }
            else
            {
                /* Force file deletion even if it's read-only */
                if (dwAttribs & FILE_ATTRIBUTE_READONLY)
                    SetFileAttributes(szFullPath, dwAttribs & ~FILE_ATTRIBUTE_READONLY);
 
                if (!DeleteFile(szFullPath))
                {
                    /* Couldn't delete the file, print out the error */
                    ErrorMessage(GetLastError(), szFullPath);
 
                    /* Restore file attributes */
                    SetFileAttributes(szFullPath, dwAttribs);
 
                    /* Continue deleting files/subfolders */
                }
            }
 
        } while (FindNextFile(hFile, &f));
        FindClose(hFile);
    }
 
    /* Ignore directory deletion if the user pressed Ctrl-C */
    if (bCtrlBreak)
        return TRUE;
 
    /*
     * Detect whether we are trying to delete a pure root drive (e.g. "C:\\", but not "C:");
     * if so, just return success. Otherwise the RemoveDirectory() call below would fail
     * and return ERROR_ACCESS_DENIED.
     */
    if (GetFullPathName(Directory, ARRAYSIZE(szFullPath), szFullPath, NULL) == 3 &&
        szFullPath[1] == _T(':') && szFullPath[2] == _T('\\'))
    {
        return TRUE;
    }
 
    /* First attempt to delete the directory */
    if (RemoveDirectory(Directory))
        return TRUE;
 
    /*
     * It failed; if it was due to an denied access, check whether it was
     * due to the directory being read-only. If so, remove its attribute
     * and retry deletion.
     */
    if (GetLastError() == ERROR_ACCESS_DENIED)
    {
        /* Force directory deletion even if it's read-only */
        dwAttribs = GetFileAttributes(Directory);
        if (dwAttribs & FILE_ATTRIBUTE_READONLY)
        {
            SetFileAttributes(Directory, dwAttribs & ~FILE_ATTRIBUTE_READONLY);
            return RemoveDirectory(Directory);
        }
    }
 
    return FALSE;
}

Referenced by cmd_rmdir(), DECLARE_INTERFACE_(), and DeleteFolder().

GetRootPath()

INT GetRootPath	(	IN LPCTSTR	InPath,
		OUT LPTSTR	OutPath,
		IN INT	size
	)

Definition at line 152 of file internal.c.

{
    if (InPath[0] && InPath[1] == _T(':'))
    {
        INT t = 0;
 
        if ((InPath[0] >= _T('0')) && (InPath[0] <= _T('9')))
        {
            t = (InPath[0] - _T('0')) + 28;
        }
        else if ((InPath[0] >= _T('a')) && (InPath[0] <= _T('z')))
        {
            t = (InPath[0] - _T('a')) + 1;
        }
        else if ((InPath[0] >= _T('A')) && (InPath[0] <= _T('Z')))
        {
            t = (InPath[0] - _T('A')) + 1;
        }
 
        return (_tgetdcwd(t, OutPath, size) == NULL);
    }
 
    /* Get current directory */
    return !GetCurrentDirectory(size, OutPath);
}

Referenced by cmd_chdir(), cmd_copy(), cmd_replace(), CommandDelete(), GetDirectory(), and getPath().

MakeFullPath()

BOOL MakeFullPath

(

TCHAR *

DirPath

)

Definition at line 325 of file internal.c.

{
    TCHAR path[MAX_PATH];
    TCHAR *p = DirPath;
    INT_PTR  n;
 
    if (CreateDirectory(DirPath, NULL))
        return TRUE;
    else if (GetLastError() != ERROR_PATH_NOT_FOUND)
        return FALSE;
 
    /* got ERROR_PATH_NOT_FOUND, so try building it up one component at a time */
    if (p[0] && p[1] == _T(':'))
        p += 2;
    while (*p == _T('\\'))
        p++; /* skip drive root */
    do
    {
        p = _tcschr(p, _T('\\'));
        n = p ? p++ - DirPath : _tcslen(DirPath);
        _tcsncpy(path, DirPath, n);
        path[n] = _T('\0');
        if ( !CreateDirectory(path, NULL) &&
            (GetLastError() != ERROR_ALREADY_EXISTS))
        {
            return FALSE;
        }
    } while (p != NULL);
 
    return TRUE;
}

Referenced by cmd_mkdir().

SetRootPath()

BOOL SetRootPath	(	TCHAR *	oldpath,
		TCHAR *	InPath
	)

Definition at line 182 of file internal.c.

{
    DWORD dwLastError;
    TCHAR OutPath[MAX_PATH];
    TCHAR OutPathTemp[MAX_PATH];
 
    StripQuotes(InPath);
 
    /* Retrieve the full path name from the (possibly relative) InPath */
    if (GetFullPathName(InPath, ARRAYSIZE(OutPathTemp), OutPathTemp, NULL) == 0)
    {
        dwLastError = GetLastError();
        goto Fail;
    }
 
    if (bEnableExtensions)
    {
        /*
         * Convert the full path to its correct case, and
         * resolve any wilcard present as well in the path
         * and retrieve the first result.
         * Example: c:\windows\SYSTEM32 => C:\WINDOWS\System32
         * Example: C:\WINDOWS\S* => C:\WINDOWS\System,
         * or C:\WINDOWS\System32, depending on the user's OS.
         */
        GetPathCase(OutPathTemp, OutPath);
    }
    else
    {
        _tcscpy(OutPath, OutPathTemp);
    }
 
    /* Use _tchdir(), since unlike SetCurrentDirectory() it updates
     * the current-directory-on-drive environment variables. */
    if (_tchdir(OutPath) != 0)
    {
        dwLastError = GetLastError();
        if (dwLastError == ERROR_FILE_NOT_FOUND)
            dwLastError = ERROR_PATH_NOT_FOUND;
        goto Fail;
    }
 
    /* Keep the original drive in ordinary CD/CHDIR (without /D switch) */
    if (oldpath != NULL && _tcsncicmp(OutPath, oldpath, 2) != 0)
        SetCurrentDirectory(oldpath);
 
    return TRUE;
 
Fail:
    ConErrFormatMessage(dwLastError);
    nErrorLevel = 1;
    return FALSE;
}

Referenced by cmd_chdir(), and CommandPushd().