workbench/c/Shell/Shell.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /* TODO:
   7    Break support (and +(0L) before execution) -- CreateNewProc()?
   8  */
   9
  10 #define DEBUG 0
  11 #include <dos/dos.h>
  12 #include <dos/stdio.h>
  13 #include <dos/cliinit.h>
  14 #include <exec/libraries.h>
  15 #include <exec/lists.h>
  16 #include <libraries/expansionbase.h>
  17 #include <proto/alib.h>
  18 #include <proto/dos.h>
  19 #include <proto/exec.h>
  20
  21 #include <ctype.h>
  22
  23 #include <aros/debug.h>
  24
  25 #include "Shell.h"
  26
  27 /* Prevent inclusion of the ErrorOutput() linklib
  28  * routine from -lamiga, so that we don't need a global
  29  * SysBase
  30  */
  31 #define ErrorOutput()  (((struct Process *)FindTask(NULL))->pr_CES)
  32
  33 #define IS_SYSTEM ((ss->flags & (FNF_VALIDFLAGS | FNF_SYSTEM)) == (FNF_VALIDFLAGS | FNF_SYSTEM))
  34 #define IS_SCRIPT (cli->cli_CurrentInput != cli->cli_StandardInput)
  35
  36 static LONG executeLine(ShellState *ss, STRPTR commandArgs);
  37
  38 BOOL setInteractive(struct CommandLineInterface *cli, ShellState *ss)
  39 {
  40     D(bug("Shell %ld: Flags = 0x%lx\n", ss->cliNumber, ss->flags));
  41     D(bug("Shell %ld: cli_Interactive = %ld\n", ss->cliNumber,
  42         cli->cli_Interactive));
  43     D(bug("Shell %ld: cli_Background = %ld\n", ss->cliNumber,
  44         cli->cli_Background));
  45     D(bug("Shell %ld: cli_CurrentInput = %p\n", ss->cliNumber,
  46         cli->cli_CurrentInput));
  47     D(bug("Shell %ld: cli_StandardInput = %p\n", ss->cliNumber,
  48         cli->cli_StandardInput));
  49     if (!cli->cli_Background && IS_SCRIPT)
  50         cli->cli_Background = DOSTRUE;
  51
  52     cli->cli_Interactive = (cli->cli_Background || IS_SCRIPT || IS_SYSTEM) ? DOSFALSE : DOSTRUE;
  53     D(bug("Shell %ld: cli_Interactive => %ld\n", ss->cliNumber,
  54         cli->cli_Interactive));
  55     D(bug("Shell %ld: cli_Background => %ld\n", ss->cliNumber,
  56         cli->cli_Background));
  57
  58     return cli->cli_Interactive;
  59 }
  60
  61 /* First we execute the script, then we interact with the user */
  62 LONG interact(ShellState *ss)
  63 {
  64     struct CommandLineInterface *cli = Cli();
  65     Buffer in = {0}, out = {0};
  66     BOOL moreLeft = FALSE;
  67     LONG error = 0;
  68
  69     setInteractive(cli, ss);
  70
  71     /* pre-allocate input buffer */
  72     if ((error = bufferAppend("?", 1, &in, SysBase))) /* FIXME drop when readLine ok */
  73         return error;
  74
  75     do {
  76         if ((error = Redirection_init(ss)) == 0)
  77         {
  78             cliPrompt(ss);
  79
  80             bufferReset(&in); /* reuse allocated buffers */
  81             bufferReset(&out);
  82
  83             D(bug("Shell %ld: Reading in a line of input...\n",
  84                 ss->cliNumber));
  85             error = readLine(ss, cli, &in, &moreLeft);
  86             D(bug("Shell %ld: moreLeft=%d, error=%ld, Line is: "
  87                 "%ld bytes (%s)\n",
  88                 ss->cliNumber, moreLeft, error, in.len, in.buf));
  89
  90             if (error == 0 && in.len > 0)
  91                 error = checkLine(ss, &in, &out, TRUE);
  92
  93             /* The command may have modified cli_Background.
  94              * C:Execute does that.
  95              */
  96             setInteractive(cli, ss);
  97
  98             /* As per AmigaMail Vol 2, "II-65: Writing a UserShell" */
  99             if (IS_SYSTEM && !IS_SCRIPT)
 100                 moreLeft = FALSE;
 101
 102             if (!cli->cli_Interactive)
 103             {
 104                 if (cli->cli_ReturnCode >= cli->cli_FailLevel) {
 105                     moreLeft = FALSE;
 106                     D(bug("Shell: cli_ReturnCode (%ld) >= cli->cli_FailLevel (%ld)\n", cli->cli_ReturnCode, cli->cli_FailLevel));
 107                 }
 108
 109                 if (CheckSignal(SIGBREAKF_CTRL_D))
 110                 {
 111                     PrintFault(ERROR_BREAK, "Shell");
 112                     moreLeft = FALSE;
 113                 }
 114             }
 115
 116             Redirection_release(ss);
 117         }
 118
 119         if (moreLeft)
 120             continue;
 121
 122         popInterpreterState(ss);
 123
 124         if (cli->cli_Interactive)
 125         {
 126             Printf("Process %ld ending\n", ss->cliNumber);
 127             Flush(Output());
 128             break;
 129         }
 130
 131         if (IS_SCRIPT) {
 132             D(bug("Shell %ld: Closing CLI input 0x%08lx\n", ss->cliNumber,
 133                 cli->cli_CurrentInput));
 134             Close(cli->cli_CurrentInput);
 135
 136             /* Now that we've closed CurrentInput, we can delete
 137              * the CommandFile.
 138              */
 139             if (AROS_BSTR_strlen(cli->cli_CommandFile))
 140             {
 141                 DeleteFile(AROS_BSTR_ADDR(cli->cli_CommandFile));
 142                 AROS_BSTR_setstrlen(cli->cli_CommandFile, 0);
 143             }
 144
 145             cli->cli_CurrentInput = cli->cli_StandardInput;
 146             cli->cli_Background = IsInteractive(cli->cli_CurrentInput) ? DOSFALSE : DOSTRUE;
 147
 148             setInteractive(cli, ss);
 149         }
 150
 151
 152         /* As per AmigaMail Vol 2, "II-65: Writing a UserShell",
 153          * if we were running a SYSTEM command, we're done now.
 154          */
 155         moreLeft = cli->cli_Interactive;
 156
 157         if (cli->cli_Interactive) {
 158             D(bug("Shell %ld: Flushing output 0x%lx, error 0x%lx\n",
 159                 ss->cliNumber, Output(), ErrorOutput()));
 160             Flush(Output());
 161             Flush(ErrorOutput());
 162         }
 163     } while (moreLeft);
 164
 165     bufferFree(&in, SysBase);
 166     bufferFree(&out, SysBase);
 167
 168     return error;
 169 }
 170
 171
 172 /* Take care of one command line */
 173 LONG checkLine(ShellState *ss, Buffer *in, Buffer *out, BOOL echo)
 174 {
 175     struct CommandLineInterface *cli = Cli();
 176     BOOL haveCommand = FALSE;
 177     LONG result;
 178
 179     result = convertLine(ss, in, out, &haveCommand);
 180
 181     if (result == 0)
 182     {
 183         D(bug("convertLine: haveCommand = %d, out->buf=%s\n", haveCommand,
 184             out->buf));
 185         /* Only a comment or dot command ? */
 186         if (haveCommand == FALSE)
 187             goto exit;
 188
 189         if (echo)
 190             cliEcho(ss, out->buf);
 191
 192         /* OK, we've got a command. Let's execute it! */
 193         result = executeLine(ss, out->buf);
 194     }
 195
 196     /* If the command changed the cli's definition
 197      * of cli_StandardInput/StandardOutput, let's
 198      * reflect that.
 199      *
 200      * This also stops redirection, so that command errors go to
 201      * the console instead of the redirected file.
 202      */
 203     SelectInput(cli->cli_StandardInput);
 204     SelectOutput(cli->cli_StandardOutput);
 205
 206     if (result)
 207     {
 208         D(bug("convertLine: error = %ld faillevel=%ld\n", result,
 209             cli->cli_FailLevel));
 210         cli->cli_Result2 = result;
 211     }
 212
 213 exit:
 214     /* FIXME error handling is bullshit */
 215
 216     cliVarNum(ss, "RC", cli->cli_ReturnCode);
 217     cliVarNum(ss, "Result2", cli->cli_Result2);
 218
 219     if (cli->cli_Interactive)
 220     {
 221         Flush(ErrorOutput());
 222         Flush(Output());
 223     }
 224
 225     return result;
 226 }
 227
 228 /* Function: unloadCommand
 229  *
 230  * Action:   Free the resources held by a (loaded) command.
 231  *
 232  * Input:    ShellState    *ss              --  this state
 233  *           BPTR           commandSeg      --  segment of the program to unload
 234  *           BOOL           homeDirChanged  --  home changed flag
 235  *
 236  * Output:   --
 237  */
 238 static void unloadCommand(ShellState *ss, BPTR commandSeg,
 239                           BOOL homeDirChanged, BOOL residentCommand)
 240 {
 241     struct CommandLineInterface *cli = Cli();
 242
 243     if (homeDirChanged)
 244         UnLock(SetProgramDir(ss->oldHomeDir));
 245
 246     SetProgramName("");
 247
 248     if (!cli->cli_Module)
 249         return;
 250
 251     if (residentCommand)
 252     {
 253         struct Segment *residentSeg = (struct Segment *)BADDR(commandSeg);
 254
 255         Forbid();
 256
 257         /* Decrease usecount */
 258         if (residentSeg->seg_UC > 0)
 259             residentSeg->seg_UC--;
 260
 261         Permit();
 262     }
 263     else
 264         UnLoadSeg(commandSeg);
 265
 266     cli->cli_Module = BNULL;
 267 }
 268
 269 /* Function: loadCommand
 270  *
 271  * Action:   Load a command, searching the resident lists, paths and C:
 272  *
 273  * Input:    ShellState    *ss              --  this state
 274  *           STRPTR         commandName     --  the command to load
 275  *           BOOL          *homeDirChanged  --  home changed result
 276  *           BPTR          *scriptLock      --  lock of script if one
 277  *
 278  * Output:   BPTR  --  segment of the loaded command or NULL if there was an
 279  *                     error
 280  */
 281 static BPTR loadCommand(ShellState *ss, STRPTR commandName, BPTR *scriptLock,
 282                         BOOL *homeDirChanged, BOOL *residentCommand)
 283 {
 284     struct CommandLineInterface *cli = Cli();
 285     BPTR oldCurDir;
 286     BPTR commandSeg = BNULL;
 287     BPTR  *paths;
 288     struct Segment *residentSeg;
 289     BOOL absolutePath = strpbrk(commandName, "/:") != NULL;
 290     BPTR file;
 291     LONG err = 0;
 292
 293     /* We check the resident lists only if we do not have an absolute path */
 294     if (!absolutePath)
 295     {
 296         Forbid();
 297
 298         /* Check regular list first... */
 299         residentSeg = FindSegment(commandName, NULL, FALSE);
 300
 301         if (residentSeg == NULL)
 302         {
 303             /* ... then the system list */
 304             residentSeg = FindSegment(commandName, NULL, TRUE);
 305         }
 306
 307         if (residentSeg != NULL)
 308         {
 309             /* Can we use this command? */
 310             if (residentSeg->seg_UC == CMD_INTERNAL || residentSeg->seg_UC >= 0)
 311             {
 312                 if (residentSeg->seg_UC >= 0)
 313                     residentSeg->seg_UC++;
 314
 315                 Permit();
 316                 *residentCommand = TRUE;
 317                 return MKBADDR(residentSeg);
 318             }
 319         }
 320
 321         Permit();
 322     }
 323
 324     oldCurDir = CurrentDir(BNULL);
 325     CurrentDir(oldCurDir);
 326
 327     file = Open(commandName, MODE_OLDFILE);
 328     err = IoErr();
 329
 330     if (!file)
 331     {
 332         if
 333         (
 334             absolutePath ||                 /* If this was an absolute path, we don't check the paths set by
 335                                                'path' or the C: multiassign */
 336             err == ERROR_OBJECT_IN_USE  /* The object might be exclusively locked */
 337         )
 338             return BNULL;
 339
 340         /* Search the command in the path */
 341         for
 342         (
 343             paths = (BPTR *)BADDR(cli->cli_CommandDir);
 344             file == BNULL && paths != NULL;
 345             paths = (BPTR *)BADDR(paths[0])    /* Go on with the next path */
 346         )
 347         {
 348             CurrentDir(paths[1]);
 349             file = Open(commandName, MODE_OLDFILE);
 350         }
 351
 352         /* The last resort -- the C: multiassign */
 353         if (!file)
 354         {
 355             commandName -= 2;
 356             file = Open(commandName, MODE_OLDFILE);
 357         }
 358     }
 359
 360     if (file)
 361     {
 362         commandSeg = LoadSeg(commandName);
 363         err = IoErr();
 364
 365         if (commandSeg)
 366         {
 367             BPTR lock = ParentOfFH(file);
 368
 369             if (lock)
 370             {
 371                 ss->oldHomeDir = SetProgramDir(lock);
 372                 *homeDirChanged = TRUE; /* TODO merge */
 373             }
 374         }
 375         /* Do not attempt to execute corrupted executables (BAD_HUNK)
 376          * Do not swallow original error code */
 377         if (!commandSeg && err == ERROR_NOT_EXECUTABLE) {
 378             struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 379             if (fib && ExamineFH(file, fib) && (fib->fib_Protection & FIBF_SCRIPT))
 380             {
 381                 commandSeg = LoadSeg("C:Execute");
 382                 if (commandSeg) {
 383                     *scriptLock = Lock(commandName, SHARED_LOCK);
 384                     if (*scriptLock == BNULL) {
 385                         UnLoadSeg(commandSeg);
 386                         commandSeg = BNULL;
 387                     }
 388                 }
 389             }
 390             else
 391                 err = ERROR_FILE_NOT_OBJECT;
 392             FreeDosObject(DOS_FIB, fib);
 393         }
 394
 395         Close(file);
 396     } else
 397         err = IoErr();
 398
 399     CurrentDir(oldCurDir);
 400     SetIoErr(err);
 401
 402     return commandSeg;
 403 }
 404
 405 /* Function: executeLine
 406  *
 407  * Action:   Execute one line of commands
 408  *
 409  * Input:    ShellState         *ss           --  this state
 410  *           STRPTR              commandArgs  --  arguments of the 'command'
 411  *
 412  * Output:   LONG  --  error code or 0 if everything went OK
 413  */
 414 static LONG executeLine(ShellState *ss, STRPTR commandArgs)
 415 {
 416     struct CommandLineInterface *cli = Cli();
 417     STRPTR command = ss->command + 2;
 418     BOOL homeDirChanged = FALSE, residentCommand = FALSE;
 419     BPTR module, scriptLock = BNULL;
 420     LONG error = 0;
 421     TEXT *cmd;
 422
 423     D(bug("[Shell] executeLine: %s %s\n", command, commandArgs));
 424
 425     cmd = AllocVec(4096 * sizeof(TEXT), MEMF_ANY);
 426     if (!cmd) {
 427         PrintFault(ERROR_NO_FREE_STORE, NULL);
 428         return ERROR_NO_FREE_STORE;
 429     }
 430
 431     module = loadCommand(ss, command, &scriptLock,
 432                          &homeDirChanged, &residentCommand);
 433
 434     /* Set command name even if we couldn't load the command to be able to
 435        report errors correctly */
 436     SetProgramName(command);
 437
 438     if (module)
 439     {
 440         struct Process *pr = (struct Process *) FindTask(NULL);
 441         ULONG defaultStack = cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT;
 442         STRPTR oldtaskname = pr->pr_Task.tc_Node.ln_Name;
 443         ULONG mem_before = 0;
 444         ULONG sig_before = pr->pr_Task.tc_SigAlloc;
 445         ULONG sig_after;
 446         ULONG sigmask;
 447         BYTE sigbit;
 448
 449         BPTR seglist = residentCommand ? ((struct Segment *)BADDR(module))->seg_Seg : module;
 450
 451         STRPTR dst = cmd, src;
 452         LONG len = 0;
 453
 454         if (scriptLock)
 455         {
 456             *dst++ = '"';
 457             if (NameFromLock(scriptLock, dst, FILE_MAX) == 0) {
 458                 error = IoErr(); /* bad FS handler ? */
 459                 goto errexit;
 460             }
 461             while (*++dst != '\0');
 462
 463             *dst++ = '"';
 464             *dst++ = ' ';
 465             UnLock(scriptLock);
 466             len = dst - cmd;
 467         }
 468
 469         src = commandArgs;
 470         for (; src && *src != '\0'; ++dst, ++src, ++len)
 471             *dst = *src;
 472         *dst = '\0';
 473
 474         D(bug("[Shell] command loaded: len=%ld, args=%s\n", len, cmd));
 475         SetIoErr(0); /* Clear error before we execute this command */
 476         SetSignal(0, SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D);
 477
 478         cli->cli_Module = seglist;
 479         pr->pr_Task.tc_Node.ln_Name = command;
 480
 481         mem_before = FindVar("__debug_mem", LV_VAR) ? AvailMem(MEMF_ANY) : 0;
 482         cli->cli_ReturnCode = RunCommand(seglist, defaultStack, cmd, len);
 483         error = (cli->cli_ReturnCode == RETURN_OK) ? 0 : IoErr();
 484
 485         /* Update the state of the cli_Interactive field */
 486         setInteractive(cli, ss);
 487
 488         /*
 489             Check if running the command has changed signal bits of the Shell
 490             process. If there is a difference the signals will be set or freed
 491             to avoid that the Shell runs out of free signals.
 492          */
 493         sig_after = pr->pr_Task.tc_SigAlloc;
 494         if (sig_before != sig_after)
 495         {
 496             for (sigbit = 0; sigbit < 32; sigbit++)
 497             {
 498                 sigmask = 1L << sigbit;
 499                 if ((sig_before & sigmask) && !(sig_after & sigmask))
 500                 {
 501                     /* Command has deleted signal => set it */
 502                     Printf("*** '%s' returned with freed signal 0x%lx\n", command, sigmask);
 503                     AllocSignal(sigbit);
 504                 }
 505                 else if (!(sig_before & sigmask) && (sig_after & sigmask))
 506                 {
 507                     /* Command has set signal => free it */
 508                     Printf("*** '%s' returned with unfreed signal 0x%lx\n", command, sigmask);
 509                     FreeSignal(sigbit);
 510                 }
 511             }
 512         }
 513
 514         if (mem_before)
 515         {
 516             ULONG mem_after = AvailMem(MEMF_ANY);
 517             Printf("Memory leak of %lu bytes\n", mem_before - mem_after);
 518         }
 519
 520         D(bug("[Shell] returned %ld (%ld): %s\n", cli->cli_ReturnCode,
 521             error, command));
 522         pr->pr_Task.tc_Node.ln_Name = oldtaskname;
 523         unloadCommand(ss, module, homeDirChanged, residentCommand);
 524
 525         /* If command couldn't be started, explain why */
 526         if (cli->cli_ReturnCode == -1)
 527             PrintFault(error, command);
 528     }
 529     else
 530     {
 531         /* SFS returns ERROR_INVALID_COMPONENT_NAME if you try to open "" */
 532         error = IoErr();
 533
 534         if (error == ERROR_OBJECT_WRONG_TYPE ||
 535             error == ERROR_OBJECT_NOT_FOUND ||
 536             error == ERROR_INVALID_COMPONENT_NAME)
 537         {
 538             BPTR lock = Lock(command, SHARED_LOCK);
 539
 540             if (lock)
 541             {
 542                 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 543
 544                 if (fib)
 545                 {
 546                     if (Examine(lock, fib))
 547                     {
 548                         if (fib->fib_DirEntryType > 0)
 549                         {
 550                             setPath(ss, lock);
 551                             lock = CurrentDir(lock);
 552                         }
 553                         else
 554                             SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 555                     }
 556
 557                     FreeDosObject(DOS_FIB, fib);
 558                 }
 559
 560                 error = IoErr();
 561
 562                 /* UnLock the old currentdir */
 563                 UnLock(lock);
 564             }
 565         }
 566         PrintFault(error, command);
 567     }
 568 errexit:
 569     FreeVec(cmd);
 570     return error;
 571 }
 572
 573 void setPath(ShellState *ss, BPTR lock)
 574 {
 575     BPTR dir;
 576     STRPTR buf;
 577     ULONG i = 0;
 578
 579     if (lock)
 580         dir = lock;
 581     else
 582         dir = CurrentDir(BNULL);
 583
 584     do
 585     {
 586         i += 256;
 587         buf = AllocVec(i, MEMF_ANY);
 588
 589         if (buf == NULL)
 590             break;
 591
 592         if (NameFromLock(dir, buf, i))
 593         {
 594             SetCurrentDirName(buf);
 595             FreeVec(buf);
 596             break;
 597         }
 598
 599         FreeVec(buf);
 600     }  while (IoErr() == ERROR_LINE_TOO_LONG);
 601
 602     if (lock == BNULL)
 603         CurrentDir(dir);
 604 }
 605
 606 #undef SysBase
 607 #undef DOSBase
 608
 609 __startup AROS_CLI(ShellStart)
 610 {
 611     LONG error;
 612     ShellState *ss;
 613     APTR DOSBase;
 614     struct Process *me = (struct Process *)FindTask(NULL);
 615     struct CommandLineInterface *cli;
 616
 617     DOSBase = OpenLibrary("dos.library",36);
 618     if (!DOSBase)
 619         return RETURN_FAIL;
 620
 621     D(bug("[Shell] executing\n"));
 622     ss = AllocMem(sizeof(ShellState), MEMF_CLEAR);
 623     if (!ss) {
 624         SetIoErr(ERROR_NO_FREE_STORE);
 625         CloseLibrary(DOSBase);
 626         return RETURN_FAIL;
 627     }
 628
 629     ss->ss_DOSBase = DOSBase;
 630     ss->ss_SysBase = SysBase;
 631
 632     /* Cache the CLI flags, passed in by the AROS_CLI() macro */
 633     ss->flags = AROS_CLI_Flags;
 634
 635     /* Select the input and output streams.
 636      * We don't use CurrentInput here, as it may
 637      * contain our script input.
 638      *
 639      * Note that if CurrentInput contained, for example:
 640      * ECHO ?
 641      * DIR
 642      *
 643      * The behaviour would be that ECHO would put its
 644      * ReadArgs query onto StandardOutput, and expects
 645      * its input on StandardInput, and then execute DIR.
 646      *
 647      * This is AOS compatible behavior. It would be
 648      * incorrect to assume that ECHO would print "DIR" on
 649      * StandardOutput
 650      */
 651     cli = Cli();
 652
 653     SelectInput(cli->cli_StandardInput);
 654     SelectOutput(cli->cli_StandardOutput);
 655     setPath(ss, BNULL);
 656
 657     ss->cliNumber = me->pr_TaskNum;
 658     cliVarNum(ss, "process", ss->cliNumber);
 659
 660     initDefaultInterpreterState(ss);
 661
 662     if (AROS_CLI_Type == CLI_RUN) {
 663         FPrintf(cli->cli_StandardError, "[CLI %ld]\n", me->pr_TaskNum);
 664     }
 665     if (AROS_CLI_Type == CLI_NEWCLI) {
 666         FPrintf(cli->cli_StandardOutput, "New Shell process %ld\n", me->pr_TaskNum);
 667     }
 668
 669     error = interact(ss);
 670
 671     D(bug("Shell %ld: exiting, error = %ld\n", ss->cliNumber, error));
 672
 673     if (ss->arg_rd)
 674         FreeDosObject(DOS_RDARGS, ss->arg_rd);
 675
 676     FreeMem(ss, sizeof(ShellState));
 677
 678     /* Make sure Input(), Output() and pr_CES don't
 679      * point to any dangling files.
 680      */
 681     SelectInput(BNULL);
 682     SelectOutput(BNULL);
 683     me->pr_CES = BNULL;
 684
 685     CloseLibrary(DOSBase);
 686
 687     return error ? RETURN_FAIL : RETURN_OK;
 688 }
 689