rom/dos/systemtaglist.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <utility/tagitem.h>
  11 #include <dos/dostags.h>
  12 #include <proto/utility.h>
  13 #include <dos/dosextens.h>
  14 #include <aros/asmcall.h>
  15 #include <exec/ports.h>
  16
  17 #include "dos_newcliproc.h"
  18 #include "dos_intern.h"
  19 #include "fs_driver.h"
  20
  21 /*****************************************************************************
  22
  23     NAME */
  24
  25 #include <proto/dos.h>
  26
  27         AROS_LH2(LONG, SystemTagList,
  28
  29 /*  SYNOPSIS */
  30         AROS_LHA(CONST_STRPTR    , command, D1),
  31         AROS_LHA(struct TagItem *, tags,    D2),
  32
  33 /*  LOCATION */
  34         struct DosLibrary *, DOSBase, 101, Dos)
  35
  36 /*  FUNCTION
  37
  38     Execute a command via a shell. As defaults, the process will use the
  39     current Input() and Output(), and the current directory as well as the
  40     path will be inherited from your process. If no path is specified, this
  41     path will be used to find the command.
  42         Normally, the boot shell is used but other shells may be specified
  43     via tags. The tags are passed through to CreateNewProc() except those
  44     that conflict with SystemTagList(). Currently, these are
  45
  46         NP_Seglist
  47         NP_FreeSeglist
  48         NP_Entry
  49         NP_Input
  50         NP_Error
  51         NP_Output
  52         NP_CloseInput
  53         NP_CloseOutput
  54         NP_CloseError
  55         NP_HomeDir
  56         NP_Cli
  57         NP_Arguments
  58         NP_Synchrounous
  59         NP_UserData
  60
  61
  62     INPUTS
  63
  64     command  --  program and arguments as a string
  65     tags     --  see <dos/dostags.h>. Note that both SystemTagList() tags and
  66                  tags for CreateNewProc() may be passed.
  67
  68     RESULT
  69
  70     The return code of the command executed or -1 if the command could
  71     not run because the shell couldn't be created. If the command is not
  72     found, the shell will return an error code, usually RETURN_ERROR.
  73
  74     NOTES
  75
  76     You must close the input and output filehandles yourself (if needed)
  77     after System() returns if they were specified via SYS_Input or
  78     SYS_Output (also, see below).
  79         You may NOT use the same filehandle for both SYS_Input and SYS_Output.
  80     If you want them to be the same CON: window, set SYS_Input to a filehandle
  81     on the CON: window and set SYS_Output to NULL. Then the shell will
  82     automatically set the output by opening CONSOLE: on that handler.
  83         If you specified SYS_Asynch, both the input and the output filehandles
  84     will be closed when the command is finished (even if this was your Input()
  85     and Output().
  86
  87     EXAMPLE
  88
  89     BUGS
  90
  91     SEE ALSO
  92
  93     Execute(), CreateNewProc(), Input(), Output(), <dos/dostags.h>
  94
  95     INTERNALS
  96
  97 *****************************************************************************/
  98 {
  99     AROS_LIBFUNC_INIT
 100
 101     struct Process *me = (struct Process *)FindTask(NULL);
 102     BPTR   cis = BNULL;
 103     BPTR   sis;
 104     BPTR   sos;
 105     BPTR   ses = BNULL;
 106     BPTR   shellseg = BNULL;
 107     STRPTR resShell    = BNULL;
 108     STRPTR shellName   = "Custom Shell";
 109     APTR   entry;
 110     BOOL sis_opened    = FALSE;
 111     BOOL cis_opened    = FALSE;
 112     BOOL sos_opened    = FALSE;
 113     BOOL ses_opened    = FALSE;
 114 #ifdef __mc68000
 115     BOOL isCLI         = TRUE;  /* Default is BCPL compatible CLI */
 116 #else
 117     BOOL isCLI         = FALSE; /* Default is C style Shell */
 118 #endif
 119     BOOL isBoot        = TRUE;
 120     BOOL isCustom      = FALSE;
 121     BOOL isAsynch      = FALSE;
 122     BOOL isBackground  = TRUE;
 123     LONG cliType       = CLI_INVALID;
 124     ULONG commandlen;
 125     LONG rc            = -1;
 126
 127     struct TagItem *tags2 = tags;
 128     struct TagItem *newtags, *tag;
 129
 130     ASSERT_VALID_PROCESS(me);
 131     D(bug("SystemTagList('%s',%p)\n", command, tags));
 132
 133     sis = Input();
 134     sos = Output();
 135
 136     while ((tag = NextTagItem(&tags2)))
 137     {
 138         D(bug("Tag=%08x Data=%08x\n", tag->ti_Tag, tag->ti_Data));
 139         switch (tag->ti_Tag)
 140         {
 141             case SYS_ScriptInput:
 142                 cis = (BPTR)tag->ti_Data;
 143                 break;
 144
 145             case SYS_Input:
 146                 sis = (BPTR)tag->ti_Data;
 147                 break;
 148
 149             case SYS_Output:
 150                 sos = (BPTR)tag->ti_Data;
 151                 break;
 152
 153             case SYS_Error:
 154                 ses = (BPTR)tag->ti_Data;
 155                 break;
 156
 157             case SYS_CustomShell:
 158                 resShell = (STRPTR)tag->ti_Data;
 159                 isCustom = TRUE;
 160                 isCLI   = FALSE;
 161                 break;
 162
 163             case SYS_UserShell:
 164                 isBoot = !tag->ti_Data;
 165                 isCustom = FALSE;
 166                 break;
 167
 168             case SYS_Asynch:
 169                 isAsynch = tag->ti_Data ? TRUE : FALSE;
 170                 break;
 171
 172             case SYS_Background:
 173                 isBackground = tag->ti_Data ? TRUE : FALSE;
 174                 break;
 175
 176             case SYS_CliType:
 177                 cliType = (LONG)tag->ti_Data;
 178                 break;
 179         }
 180     }
 181
 182     /* Validate cliType */
 183     switch (cliType) {
 184     case CLI_SYSTEM:
 185         isAsynch = FALSE;
 186         isBackground = TRUE;
 187         break;
 188     case CLI_BOOT:
 189         isAsynch = TRUE;
 190         isBackground = FALSE;
 191         break;
 192     case CLI_NEWCLI:
 193         isAsynch = TRUE;
 194         isBackground = FALSE;
 195         break;
 196     case CLI_RUN:
 197     case CLI_ASYSTEM:
 198         isAsynch = TRUE;
 199         isBackground = TRUE;
 200         break;
 201     case CLI_INVALID:
 202         /* default */
 203         if (isBackground)
 204             cliType = isAsynch ? CLI_ASYSTEM : CLI_SYSTEM;
 205         else
 206             cliType = isAsynch ? CLI_NEWCLI : CLI_BOOT;
 207         break;
 208     default:
 209         /* invalid */
 210         goto end;
 211     }
 212
 213     /* Set up the streams */
 214     if (sis == (BPTR)SYS_DupStream)
 215     {
 216         sis = OpenFromLock(DupLockFromFH(Input()));
 217         if (!sis) goto end;
 218
 219         sis_opened = TRUE;
 220     }
 221     if (sis == BNULL) {
 222         sis = Open("NIL:", MODE_OLDFILE);
 223         if (!sis) goto end;
 224
 225         sis_opened = TRUE;
 226     }
 227     D(bug("[SystemTagList] cli_StandardInput: %p\n", sis));
 228
 229     if (cis == BNULL || cis == (BPTR)SYS_DupStream)
 230         cis = sis;
 231     D(bug("[SystemTagList] cli_CurrentInput: %p\n", cis));
 232
 233     if (sos == (BPTR)SYS_DupStream)
 234     {
 235         sos = OpenFromLock(DupLockFromFH(Output()));
 236         if (!sos) goto end;
 237
 238         sos_opened = TRUE;
 239     }
 240     D(bug("[SystemTagList] cli_StandardOutput: %p\n", sos));
 241
 242     if (ses == (BPTR)SYS_DupStream)
 243     {
 244         ses = OpenFromLock(DupLockFromFH(me->pr_CES));
 245         if (!ses) goto end;
 246
 247         ses_opened = TRUE;
 248     }
 249     D(bug("[SystemTagList] cli_StandardError: %p\n", ses));
 250
 251     /* Inject the arguments, adding a trailing '\n'
 252      * if the user did not.
 253      */
 254     if (command == NULL)
 255         command = "";
 256
 257     commandlen = strlen(command);
 258     if (commandlen) {
 259         STRPTR cmdcopy = NULL;
 260         BOOL ok;
 261
 262         if (command[commandlen-1] != '\n') {
 263             cmdcopy = AllocVec(commandlen + 2, MEMF_ANY);
 264             CopyMem(command, cmdcopy, commandlen);
 265             cmdcopy[commandlen++] = '\n';
 266             cmdcopy[commandlen] = 0;
 267             command = cmdcopy;
 268         }
 269
 270         ok = vbuf_inject(cis, command, commandlen, DOSBase);
 271         if (cmdcopy)
 272             FreeVec(cmdcopy);
 273
 274         if (!ok)
 275             goto end;
 276     }
 277
 278     /* Load the shell */
 279     if (!isCustom) {
 280         /* Seglist of default shell is stored in RootNode when loaded */
 281         if (isCLI)
 282             shellseg = findseg_cli(isBoot, DOSBase);
 283         else
 284             shellseg = findseg_shell(isBoot, DOSBase);
 285         /*
 286          * Set shell process name.
 287          */
 288         if (isCLI)
 289             shellName = "CLI";
 290         else
 291             shellName = "Shell";
 292     } else if (resShell != BNULL) {
 293         struct Segment *seg;
 294
 295         /* Get the custom shell from the DOS resident list */
 296         Forbid();
 297         seg = FindSegment(resShell, NULL, TRUE);
 298         if (seg)
 299             shellseg = seg->seg_Seg;
 300         Permit();
 301
 302         shellName = resShell;
 303     }
 304
 305     if (!shellseg && isCLI) {
 306         /* We wanted the CLI shell, but it's not available.
 307          * Let's try to use the Shell instead.
 308          */
 309         shellseg = findseg_shell(isBoot, DOSBase);
 310         isCLI = FALSE;
 311     }
 312
 313     if (!shellseg) {
 314         D(bug("[SystemTagList] No shell available\n"));
 315         goto end;
 316     }
 317
 318 #ifdef __mc68000
 319     if (isCLI)
 320     {
 321         D(bug("[SystemTagList] BCPL 'CLI' shell selected\n"));
 322         /* On the m68k AOS, the "CLI" shell was always a BCPL
 323          * program, that ran like a BCPL DOS packet handler.
 324          */
 325         extern void BCPL_RunHandler(void);
 326         entry = BCPL_RunHandler;
 327     }
 328     else
 329 #endif
 330     {
 331         D(bug("[SystemTagList] C 'shell' shell selected\n"));
 332         /* Use the standard C entry point */
 333         entry = NULL;
 334     }
 335
 336     newtags = CloneTagItems(tags);
 337     if (newtags)
 338     {
 339         struct Process *cliproc;
 340
 341         struct TagItem proctags[] =
 342         {
 343             { NP_Priority   , me->pr_Task.tc_Node.ln_Pri    }, /* 0  */
 344             { NP_Name       , (IPTR)shellName               }, /* 1  */
 345             { NP_Input      , (IPTR)BNULL                   }, /* 2  */
 346             { NP_Output     , (IPTR)BNULL                   }, /* 3  */
 347             { NP_Error      , (IPTR)ses                     }, /* 4  */
 348             { NP_CloseInput , FALSE                         }, /* 5  */
 349             { NP_CloseOutput, FALSE                         }, /* 6  */
 350             { NP_CloseError , (isAsynch || ses_opened)
 351                                       ? TRUE : FALSE,       }, /* 7  */
 352             { NP_Cli        , (cliType == CLI_NEWCLI)
 353                                       ?  TRUE : FALSE       }, /* 8  */
 354             { NP_WindowPtr  , isAsynch ? (IPTR)NULL :
 355                               (IPTR)me->pr_WindowPtr        }, /* 9  */
 356             { NP_Seglist    , (IPTR)shellseg                }, /* 10 */
 357             { NP_FreeSeglist, FALSE                         }, /* 11 */
 358             { NP_Synchronous, FALSE                         }, /* 12 */
 359             { NP_Entry      , (IPTR)entry                   }, /* 13 */
 360             { NP_CurrentDir , (IPTR)BNULL                   }, /* 14 */
 361             { NP_ConsoleTask, (IPTR)BNULL,                  }, /* 15 */
 362             { TAG_END       , 0                             }  /* 16 */
 363         };
 364
 365         Tag filterList[] =
 366         {
 367             NP_Seglist,
 368             NP_FreeSeglist,
 369             NP_Entry,
 370             NP_Input,
 371             NP_Output,
 372             NP_CloseInput,
 373             NP_CloseOutput,
 374             NP_CloseError,
 375             NP_HomeDir,
 376             NP_Cli,
 377             NP_Arguments,
 378             NP_Synchronous,
 379             NP_UserData,
 380             0
 381         };
 382
 383         struct DosPacket *dp;
 384
 385         FilterTagItems(newtags, filterList, TAGFILTER_NOT);
 386
 387         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Tag  = TAG_MORE;
 388         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Data = (IPTR)newtags;
 389
 390         dp = AllocDosObject(DOS_STDPKT, NULL);
 391         if (dp) {
 392             cliproc = CreateNewProc(proctags);
 393
 394             if (cliproc)
 395             {
 396                 SIPTR oldSignal = 0;
 397                 struct FileHandle *fh = NULL;
 398
 399                 D(bug("[SystemTagList] cliType = %d (background=%d, asynch=%d)\n", cliType, isBackground, isAsynch));
 400 #ifdef __mc68000
 401                 /* Trickery needed for BCPL user shells.
 402                  * This is needed for the trimmed AROS m68k
 403                  * ROMs that don't have shell.resource, and
 404                  * load the CLI from a BCPL L:Shell-Seg, like
 405                  * the one on Workbench 1.3
 406                  */
 407                 if (isCLI) {
 408                     extern void BCPL_CliInit_NEWCLI(void);
 409                     extern void BCPL_CliInit_RUN(void);
 410                     extern void BCPL_CliInit_SYSTEM(void);
 411                     extern void BCPL_CliInit_ASYSTEM(void);
 412                     extern void BCPL_CliInit_SYSTEM(void);
 413                     extern void BCPL_CliInit_BOOT(void);
 414                     switch (cliType) {
 415                     case CLI_NEWCLI:  dp->dp_Type = (LONG)BCPL_CliInit_NEWCLI;  break;
 416                     case CLI_RUN:     dp->dp_Type = (LONG)BCPL_CliInit_RUN;     break;
 417                     case CLI_SYSTEM:  dp->dp_Type = (LONG)BCPL_CliInit_SYSTEM;  break;
 418                     case CLI_ASYSTEM: dp->dp_Type = (LONG)BCPL_CliInit_ASYSTEM; break;
 419                     case CLI_BOOT:    dp->dp_Type = (LONG)BCPL_CliInit_BOOT;    break;
 420                     default: goto end;
 421                     }
 422                 } else /* Fallthough to the next line for user shells */
 423 #endif
 424                 dp->dp_Type = cliType;
 425                 dp->dp_Res2 = 0;
 426                 dp->dp_Arg2 = (IPTR)sis;        /* Input */
 427                 dp->dp_Arg3 = (IPTR)sos;        /* Output */
 428                 dp->dp_Arg4 = (IPTR)cis;        /* Arguments & Script*/
 429
 430                 /* The rest of the packet depends on the cliType. */
 431                 if (cliType == CLI_NEWCLI) {
 432                     /* CliInitNewcli style */
 433                     dp->dp_Res1 = 1;
 434                     dp->dp_Arg1 = (IPTR)(me->pr_CurrentDir ? DupLock(me->pr_CurrentDir) : BNULL);
 435                 } else {
 436                     /* CliInitRun style */
 437                     dp->dp_Res1 = 0;
 438                     dp->dp_Arg1 = (IPTR)(__is_process(me) ? MKBADDR(Cli()) : BNULL);
 439                     dp->dp_Arg5 = (IPTR)(me->pr_CurrentDir ? DupLock(me->pr_CurrentDir) : BNULL);
 440                     dp->dp_Arg6 = 1;
 441                 }
 442
 443                 /* Migrate the CIS handle to the new process */
 444                 if (!isAsynch && IsInteractive(sis)) {
 445                     fh = BADDR(sis);
 446
 447                     if (dopacket(&oldSignal, fh->fh_Type, ACTION_CHANGE_SIGNAL, (SIPTR)fh->fh_Arg1, (SIPTR)&cliproc->pr_MsgPort, 0, 0, 0, 0, 0) == DOSFALSE)
 448                         oldSignal = 0;
 449                 }
 450
 451                 SendPkt(dp, &cliproc->pr_MsgPort, &me->pr_MsgPort);
 452                 if (WaitPkt() != dp)
 453                     Alert(AN_QPktFail);
 454
 455                 if (fh && oldSignal) {
 456                     DoPkt(fh->fh_Type, ACTION_CHANGE_SIGNAL, (SIPTR)fh->fh_Arg1, oldSignal, 0, 0, 0);
 457                 }
 458
 459                 rc = dp->dp_Res1;
 460                 SetIoErr(dp->dp_Res2);
 461
 462                 cis_opened = FALSE;
 463                 if (isAsynch) {
 464                     sis_opened    =
 465                     sos_opened    =
 466                     ses_opened    = FALSE;
 467                 }
 468             }
 469
 470             FreeDosObject(DOS_STDPKT, dp);
 471         }
 472         FreeTagItems(newtags);
 473     }
 474
 475 end:
 476     if (sis_opened)    Close(sis);
 477     if (cis_opened)    Close(cis);
 478     if (sos_opened)    Close(sos);
 479     if (ses_opened)    Close(ses);
 480
 481     return rc;
 482
 483     AROS_LIBFUNC_EXIT
 484 } /* SystemTagList */