reactos/base/shell/cmd/internal.c

   1 /*
   2  *  INTERNAL.C - command.com internal commands.
   3  *
   4  *
   5  *  History:
   6  *
   7  *  17/08/94 (Tim Norman)
   8  *    started.
   9  *
  10  *  08/08/95 (Matt Rains)
  11  *    i have cleaned up the source code. changes now bring this source into
  12  *    guidelines for recommended programming practice.
  13  *
  14  *  cd()
  15  *    started.
  16  *
  17  *  dir()
  18  *    i have added support for file attributes to the DIR() function. the
  19  *    routine adds "d" (directory) and "r" (read only) output. files with the
  20  *    system attribute have the filename converted to lowercase. files with
  21  *    the hidden attribute are not displayed.
  22  *
  23  *    i have added support for directorys. now if the directory attribute is
  24  *    detected the file size if replaced with the string "<dir>".
  25  *
  26  *  ver()
  27  *    started.
  28  *
  29  *  md()
  30  *    started.
  31  *
  32  *  rd()
  33  *    started.
  34  *
  35  *  del()
  36  *    started.
  37  *
  38  *  does not support wildcard selection.
  39  *
  40  *  todo: add delete directory support.
  41  *        add recursive directory delete support.
  42  *
  43  *  ren()
  44  *    started.
  45  *
  46  *  does not support wildcard selection.
  47  *
  48  *    todo: add rename directory support.
  49  *
  50  *  a general structure has been used for the cd, rd and md commands. this
  51  *  will be better in the long run. it is too hard to maintain such diverse
  52  *  functions when you are involved in a group project like this.
  53  *
  54  *  12/14/95 (Tim Norman)
  55  *    fixed DIR so that it will stick \*.* if a directory is specified and
  56  *    that it will stick on .* if a file with no extension is specified or
  57  *    *.* if it ends in a \
  58  *
  59  *  1/6/96 (Tim Norman)
  60  *    added an isatty call to DIR so it won't prompt for keypresses unless
  61  *    stdin and stdout are the console.
  62  *
  63  *    changed parameters to be mutually consistent to make calling the
  64  *    functions easier
  65  *
  66  *  rem()
  67  *    started.
  68  *
  69  *  doskey()
  70  *    started.
  71  *
  72  *    01/22/96 (Oliver Mueller)
  73  *        error messages are now handled by perror.
  74  *
  75  *    02/05/96 (Tim Norman)
  76  *        converted all functions to accept first/rest parameters
  77  *
  78  *    07/26/96 (Tim Norman)
  79  *        changed return values to int instead of void
  80  *
  81  *        path() started.
  82  *
  83  *    12/23/96 (Aaron Kaufman)
  84  *        rewrote dir() to mimic MS-DOS's dir
  85  *
  86  *    01/28/97 (Tim Norman)
  87  *        cleaned up Aaron's DIR code
  88  *
  89  *    06/13/97 (Tim Norman)
  90  *        moved DIR code to dir.c
  91  *        re-implemented Aaron's DIR code
  92  *
  93  *    06/14/97 (Steffan Kaiser)
  94  *        ctrl-break handling
  95  *        bug fixes
  96  *
  97  *    27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
  98  *        added config.h include
  99  *
 100  *    03-Dec-1998 (Eric Kohl)
 101  *        Replaced DOS calls by Win32 calls.
 102  *
 103  *    08-Dec-1998 (Eric Kohl)
 104  *        Added help texts ("/?").
 105  *
 106  *    18-Dec-1998 (Eric Kohl)
 107  *        Added support for quoted arguments (cd "program files").
 108  *
 109  *    07-Jan-1999 (Eric Kohl)
 110  *        Clean up.
 111  *
 112  *    26-Jan-1999 (Eric Kohl)
 113  *        Replaced remaining CRT io functions by Win32 io functions.
 114  *        Unicode safe!
 115  *
 116  *    30-Jan-1999 (Eric Kohl)
 117  *        Added "cd -" feature. Changes to the previous directory.
 118  *
 119  *    15-Mar-1999 (Eric Kohl)
 120  *        Fixed bug in "cd -" feature. If the previous directory was a root
 121  *        directory, it was ignored.
 122  *
 123  *    23-Feb-2001 (Carl Nettelblad <cnettel@hem.passagen.se>)
 124  *        Improved chdir/cd command.
 125  *
 126  *    02-Apr-2004 (Magnus Olsen <magnus@greatlord.com>)
 127  *        Remove all hard code string so they can be
 128  *        translate to other langues.
 129  *
 130  *    19-Jul-2005 (Brandon Turner <turnerb7@msu.edu>)
 131  *        Rewrite the CD, it working as Windows 2000 CMD
 132  *
 133  *    19-Jul-2005 (Magnus Olsen <magnus@greatlord.com>)
 134  *        Add SetRootPath and GetRootPath
 135  *
 136  *    14-Jul-2007 (Pierre Schweitzer <heis_spiter@hotmail.com>)
 137  *        Added commands help display to help command (ex. : "help cmd")
 138  */
 139
 140 #include "precomp.h"
 141
 142 #ifdef INCLUDE_CMD_CHDIR
 143
 144 /* help functions for getting current path from drive
 145    without changing drive. Return code 0 = ok, 1 = fail.
 146    INT GetRootPath("C:",outbuffer,chater size of outbuffer);
 147    the first param can have any size, if the the two frist
 148    letter are not a drive with : it will get Currentpath on
 149    current drive exacly as GetCurrentDirectory does.
 150    */
 151
 152 INT GetRootPath(TCHAR *InPath,TCHAR *OutPath,INT size)
 153 {
 154     if (InPath[0] && InPath[1] == _T(':'))
 155     {
 156         INT t=0;
 157
 158         if ((InPath[0] >= _T('0')) && (InPath[0] <= _T('9')))
 159         {
 160             t = (InPath[0] - _T('0')) +28;
 161         }
 162
 163         if ((InPath[0] >= _T('a')) && (InPath[0] <= _T('z')))
 164         {
 165             t = (InPath[0] - _T('a')) +1;
 166             InPath[0] = t + _T('A') - 1;
 167         }
 168
 169         if ((InPath[0] >= _T('A')) && (InPath[0] <= _T('Z')))
 170         {
 171             t = (InPath[0] - _T('A')) +1;
 172         }
 173
 174         return _tgetdcwd(t,OutPath,size) == NULL;
 175     }
 176
 177     /* Get current directory */
 178     return !GetCurrentDirectory(size,OutPath);
 179 }
 180
 181
 182 BOOL SetRootPath(TCHAR *oldpath, TCHAR *InPath)
 183 {
 184     TCHAR OutPath[MAX_PATH];
 185     TCHAR OutPathTemp[MAX_PATH];
 186
 187     /* The use of both of these together will correct the case of a path
 188      where as one alone or GetFullPath will not.  Exameple:
 189       c:\windows\SYSTEM32 => C:\WINDOWS\system32 */
 190     if (GetFullPathName(InPath, MAX_PATH, OutPathTemp, NULL))
 191     {
 192         GetPathCase(OutPathTemp, OutPath);
 193
 194         /* Use _tchdir, since unlike SetCurrentDirectory it updates
 195          * the current-directory-on-drive environment variables. */
 196         if (_tchdir(OutPath) != 0)
 197         {
 198             ConErrFormatMessage(GetLastError());
 199             nErrorLevel = 1;
 200             return FALSE;
 201         }
 202
 203         /* Keep original drive in ordinary CD/CHDIR (without /D switch). */
 204         if (oldpath != NULL && _tcsncicmp(OutPath, oldpath, 2) != 0)
 205             SetCurrentDirectory(oldpath);
 206     }
 207
 208     return TRUE;
 209 }
 210
 211
 212 /*
 213  * CD / CHDIR
 214  *
 215  */
 216 INT cmd_chdir (LPTSTR param)
 217 {
 218     TCHAR szCurrent[MAX_PATH];
 219     BOOL bChangeDrive = FALSE;
 220
 221     /* Filter out special cases first */
 222
 223     /* Print Help */
 224     if (!_tcsncmp(param, _T("/?"), 2))
 225     {
 226         ConOutResPaging(TRUE,STRING_CD_HELP);
 227         return 0;
 228     }
 229
 230     /* Remove " */
 231     StripQuotes(param);
 232
 233     /* Set Error Level to Success */
 234     nErrorLevel = 0;
 235
 236     /* Print Current Directory on a disk */
 237     if (_tcslen(param) == 2 && param[1] == _T(':'))
 238     {
 239         if (GetRootPath(param, szCurrent, MAX_PATH))
 240         {
 241             error_invalid_drive();
 242             return 1;
 243         }
 244         ConOutPuts(szCurrent);
 245         return 0;
 246     }
 247
 248     /* Get Current Directory */
 249     GetCurrentDirectory(MAX_PATH, szCurrent);
 250     if (param[0] == _T('\0'))
 251     {
 252         ConOutPuts(szCurrent);
 253         return 0;
 254     }
 255
 256     /* Input String Contains /D Switch */
 257     if (!_tcsncicmp(param, _T("/D"), 2))
 258     {
 259         bChangeDrive = TRUE;
 260         param += 2;
 261         while (_istspace(*param))
 262             param++;
 263     }
 264
 265     if (!SetRootPath(bChangeDrive ? NULL : szCurrent, param))
 266         return 1;
 267
 268     return 0;
 269 }
 270
 271 #endif
 272
 273 #ifdef INCLUDE_CMD_MKDIR
 274
 275 /* Helper funtion for mkdir to make directories in a path.
 276 Dont use the api to decrease depence on libs */
 277 BOOL
 278 MakeFullPath(TCHAR * DirPath)
 279 {
 280     TCHAR path[MAX_PATH];
 281     TCHAR *p = DirPath;
 282     INT_PTR  n;
 283
 284     if (CreateDirectory(DirPath, NULL))
 285         return TRUE;
 286     else if (GetLastError() != ERROR_PATH_NOT_FOUND)
 287         return FALSE;
 288
 289     /* got ERROR_PATH_NOT_FOUND, so try building it up one component at a time */
 290     if (p[0] && p[1] == _T(':'))
 291         p += 2;
 292     while (*p == _T('\\'))
 293         p++; /* skip drive root */
 294     do
 295     {
 296         p = _tcschr(p, _T('\\'));
 297         n = p ? p++ - DirPath : _tcslen(DirPath);
 298         _tcsncpy(path, DirPath, n);
 299         path[n] = _T('\0');
 300         if ( !CreateDirectory(path, NULL) &&
 301             (GetLastError() != ERROR_ALREADY_EXISTS))
 302         {
 303             return FALSE;
 304         }
 305     } while (p != NULL);
 306
 307     return TRUE;
 308 }
 309
 310 /*
 311  * MD / MKDIR
 312  */
 313 INT cmd_mkdir (LPTSTR param)
 314 {
 315     LPTSTR *p;
 316     INT argc, i;
 317     if (!_tcsncmp (param, _T("/?"), 2))
 318     {
 319         ConOutResPaging(TRUE,STRING_MKDIR_HELP);
 320         return 0;
 321     }
 322
 323     p = split (param, &argc, FALSE, FALSE);
 324     if (argc == 0)
 325     {
 326         ConErrResPuts(STRING_ERROR_REQ_PARAM_MISSING);
 327         nErrorLevel = 1;
 328         freep(p);
 329         return 1;
 330     }
 331
 332     nErrorLevel = 0;
 333     for (i = 0; i < argc; i++)
 334     {
 335         if (!MakeFullPath(p[i]))
 336         {
 337             if (GetLastError() == ERROR_PATH_NOT_FOUND)
 338             {
 339                 ConErrResPuts(STRING_MD_ERROR2);
 340             }
 341             else
 342             {
 343                 ErrorMessage (GetLastError(), _T("MD"));
 344             }
 345             nErrorLevel = 1;
 346         }
 347     }
 348
 349     freep (p);
 350     return nErrorLevel;
 351 }
 352 #endif
 353
 354
 355 #ifdef INCLUDE_CMD_RMDIR
 356 /*
 357  * RD / RMDIR
 358  */
 359 BOOL DeleteFolder(LPTSTR FileName)
 360 {
 361     TCHAR Base[MAX_PATH];
 362     TCHAR TempFileName[MAX_PATH];
 363     HANDLE hFile;
 364     WIN32_FIND_DATA f;
 365     _tcscpy(Base,FileName);
 366     _tcscat(Base,_T("\\*"));
 367     hFile = FindFirstFile(Base, &f);
 368     Base[_tcslen(Base) - 1] = _T('\0');
 369     if (hFile != INVALID_HANDLE_VALUE)
 370     {
 371         do
 372         {
 373             if (!_tcscmp(f.cFileName, _T(".")) ||
 374                 !_tcscmp(f.cFileName, _T("..")))
 375                 continue;
 376             _tcscpy(TempFileName,Base);
 377             _tcscat(TempFileName,f.cFileName);
 378
 379             if (f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 380                 DeleteFolder(TempFileName);
 381             else
 382             {
 383                 SetFileAttributes(TempFileName,FILE_ATTRIBUTE_NORMAL);
 384                 if (!DeleteFile(TempFileName))
 385                     return 0;
 386             }
 387
 388         }while (FindNextFile (hFile, &f));
 389         FindClose (hFile);
 390     }
 391     return RemoveDirectory(FileName);
 392 }
 393
 394 INT cmd_rmdir (LPTSTR param)
 395 {
 396     TCHAR ch;
 397     INT args;
 398     INT dirCount;
 399     LPTSTR *arg;
 400     INT i;
 401     BOOL RD_SUB = FALSE;
 402     BOOL RD_QUIET = FALSE;
 403     INT res;
 404     INT nError = 0;
 405     TCHAR szFullPath[MAX_PATH];
 406
 407     if (!_tcsncmp (param, _T("/?"), 2))
 408     {
 409         ConOutResPaging(TRUE,STRING_RMDIR_HELP);
 410         return 0;
 411     }
 412
 413     arg = split (param, &args, FALSE, FALSE);
 414     dirCount = 0;
 415
 416     /* check for options anywhere in command line */
 417     for (i = 0; i < args; i++)
 418     {
 419         if (*arg[i] == _T('/'))
 420         {
 421             /*found a command, but check to make sure it has something after it*/
 422             if (_tcslen (arg[i]) == 2)
 423             {
 424                 ch = _totupper (arg[i][1]);
 425
 426                 if (ch == _T('S'))
 427                 {
 428                     RD_SUB = TRUE;
 429                 }
 430                 else if (ch == _T('Q'))
 431                 {
 432                     RD_QUIET = TRUE;
 433                 }
 434             }
 435         }
 436         else
 437         {
 438             dirCount++;
 439         }
 440     }
 441
 442     if (dirCount == 0)
 443     {
 444         /* No folder to remove */
 445         error_req_param_missing();
 446         freep(arg);
 447         return 1;
 448     }
 449
 450     for (i = 0; i < args; i++)
 451     {
 452         if (*arg[i] == _T('/'))
 453             continue;
 454
 455         if (RD_SUB)
 456         {
 457             /* ask if they want to delete evrything in the folder */
 458             if (!RD_QUIET)
 459             {
 460                 res = FilePromptYNA (STRING_DEL_HELP2);
 461                 if (res == PROMPT_NO || res == PROMPT_BREAK)
 462                 {
 463                     nError = 1;
 464                     continue;
 465                 }
 466                 if (res == PROMPT_ALL)
 467                     RD_QUIET = TRUE;
 468             }
 469             /* get the folder name */
 470             GetFullPathName(arg[i],MAX_PATH,szFullPath,NULL);
 471
 472             /* remove trailing \ if any, but ONLY if dir is not the root dir */
 473             if (_tcslen (szFullPath) >= 2 && szFullPath[_tcslen (szFullPath) - 1] == _T('\\'))
 474                 szFullPath[_tcslen(szFullPath) - 1] = _T('\0');
 475
 476             res = DeleteFolder(szFullPath);
 477         }
 478         else
 479         {
 480             res = RemoveDirectory(arg[i]);
 481         }
 482
 483         if (!res)
 484         {
 485             /* Couldn't delete the folder, print out the error */
 486             nError = GetLastError();
 487             ErrorMessage(nError, _T("RD"));
 488         }
 489     }
 490
 491     freep (arg);
 492     return nError;
 493 }
 494 #endif
 495
 496
 497 /*
 498  * set the exitflag to true
 499  */
 500 INT CommandExit (LPTSTR param)
 501 {
 502     if (!_tcsncmp (param, _T("/?"), 2))
 503     {
 504         ConOutResPaging(TRUE,STRING_EXIT_HELP);
 505         /* Just make sure */
 506         bExit = FALSE;
 507         /* Dont exit */
 508         return 0;
 509     }
 510
 511     if (bc != NULL && _tcsnicmp(param,_T("/b"),2) == 0)
 512     {
 513         param += 2;
 514         while (_istspace (*param))
 515             param++;
 516         if (_istdigit(*param))
 517             nErrorLevel = _ttoi(param);
 518         ExitBatch();
 519     }
 520     else
 521     {
 522         bExit = TRUE;
 523     }
 524
 525     return 0;
 526 }
 527
 528 #ifdef INCLUDE_CMD_REM
 529 /*
 530  * does nothing
 531  */
 532 INT CommandRem (LPTSTR param)
 533 {
 534     if (!_tcsncmp (param, _T("/?"), 2))
 535     {
 536         ConOutResPaging(TRUE,STRING_REM_HELP);
 537     }
 538
 539     return 0;
 540 }
 541 #endif /* INCLUDE_CMD_REM */
 542
 543
 544 INT CommandShowCommands (LPTSTR param)
 545 {
 546     PrintCommandList();
 547     return 0;
 548 }
 549
 550 /* EOF */