rom/dos/systemtaglist.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #ifdef DEBUG
  10 #undef DEBUG
  11 #endif
  12 # define  DEBUG 1
  13 # include <aros/debug.h>
  14
  15 #include "dos_newcliproc.h"
  16 #include "dos_intern.h"
  17 #include <utility/tagitem.h>
  18 #include <dos/dostags.h>
  19 #include <proto/utility.h>
  20 #include <dos/dosextens.h>
  21 #include <aros/asmcall.h>
  22 #include <exec/ports.h>
  23
  24 static BPTR DupFH(BPTR fh, LONG mode, struct DosLibrary * DOSBase);
  25
  26 /*****************************************************************************
  27
  28     NAME */
  29
  30 #include <proto/dos.h>
  31
  32         AROS_LH2(LONG, SystemTagList,
  33
  34 /*  SYNOPSIS */
  35         AROS_LHA(CONST_STRPTR    , command, D1),
  36         AROS_LHA(struct TagItem *, tags,    D2),
  37
  38 /*  LOCATION */
  39         struct DosLibrary *, DOSBase, 101, Dos)
  40
  41 /*  FUNCTION
  42
  43     Execute a command via a shell. As defaults, the process will use the
  44     current Input() and Output(), and the current directory as well as the
  45     path will be inherited from your process. If no path is specified, this
  46     path will be used to find the command.
  47         Normally, the boot shell is used but other shells may be specified
  48     via tags. The tags are passed through to CreateNewProc() except those
  49     who conflict with SystemTagList(). Currently, these are
  50
  51         NP_Seglist
  52         NP_FreeSeglist
  53         NP_Entry
  54         NP_Input
  55         NP_Error
  56         NP_Output
  57         NP_CloseInput
  58         NP_CloseOutput
  59         NP_CloseError
  60         NP_HomeDir
  61         NP_Cli
  62         NP_Arguments
  63         NP_Synchrounous
  64         NP_UserData
  65
  66
  67     INPUTS
  68
  69     command  --  program and arguments as a string
  70     tags     --  see <dos/dostags.h>. Note that both SystemTagList() tags and
  71                  tags for CreateNewProc() may be passed.
  72
  73     RESULT
  74
  75     The return code of the command executed or -1 or if the command could
  76     not run because the shell couldn't be created. If the command is not
  77     found, the shell will return an error code, usually RETURN_ERROR.
  78
  79     NOTES
  80
  81     You must close the input and output filehandles yourself (if needed)
  82     after System() returns if they were specified via SYS_Input or
  83     SYS_Output (also, see below).
  84         You may NOT use the same filehandle for both SYS_Input and SYS_Output.
  85     If you want them to be the same CON: window, set SYS_Input to a filehandle
  86     on the CON: window and set SYS_Output to NULL. Then the shell will
  87     automatically set the output by opening CONSOLE: on that handler.
  88         If you specified SYS_Asynch, both the input and the output filehandles
  89     will be closed when the command is finished (even if this was your Input()
  90     and Output().
  91
  92     EXAMPLE
  93
  94     BUGS
  95
  96     SEE ALSO
  97
  98     Execute(), CreateNewProc(), Input(), Output(), <dos/dostags.h>
  99
 100     INTERNALS
 101
 102 *****************************************************************************/
 103 {
 104     AROS_LIBFUNC_INIT
 105
 106     BPTR   cis = Input(), cos = Output(), ces = Error(), script = NULL;
 107     BPTR   shellseg = NULL;
 108     STRPTR cShell   = NULL;
 109     BOOL script_opened = FALSE;
 110     BOOL cis_opened    = FALSE;
 111     BOOL cos_opened    = FALSE;
 112     BOOL ces_opened    = FALSE;
 113     BOOL isBoot        = TRUE;
 114     BOOL isBackground  = TRUE;
 115     BOOL isAsynch      = FALSE;
 116     LONG rc            = -1;
 117     LONG *cliNumPtr    = NULL;
 118
 119     const struct TagItem *tags2 = tags;
 120     struct TagItem *newtags, *tag;
 121
 122     while ((tag = NextTagItem(&tags2)))
 123     {
 124         switch (tag->ti_Tag)
 125         {
 126             case SYS_ScriptInput:
 127                 script = (BPTR)tag->ti_Data;
 128                 break;
 129
 130             case SYS_Input:
 131                 cis = (BPTR)tag->ti_Data;
 132                 break;
 133
 134             case SYS_Output:
 135                 cos = (BPTR)tag->ti_Data;
 136                 break;
 137
 138             case SYS_Error:
 139                 ces = (BPTR)tag->ti_Data;
 140                 break;
 141
 142             case SYS_CustomShell:
 143                 cShell = (STRPTR)tag->ti_Data;
 144                 break;
 145
 146             case SYS_UserShell:
 147                 isBoot = !tag->ti_Data;
 148                 break;
 149
 150             case SYS_Background:
 151                 isBackground = tag->ti_Data ? TRUE : FALSE;
 152                 break;
 153
 154             case SYS_Asynch:
 155                 isAsynch = tag->ti_Data ? TRUE : FALSE;
 156                 break;
 157
 158             case SYS_CliNumPtr:
 159                 cliNumPtr = (LONG *)tag->ti_Data;
 160                 break;
 161         }
 162     }
 163
 164     /* Set up the streams */
 165     if (!cis)
 166     {
 167         cis = Open("NIL:", FMF_READ);
 168         if (!cis) goto end;
 169
 170         cis_opened = TRUE;
 171     }
 172     else
 173     if (cis == (BPTR)SYS_DupStream)
 174     {
 175         cis = DupFH(Input(), FMF_READ, DOSBase);
 176         if (!cis) goto end;
 177
 178         cis_opened = TRUE;
 179     }
 180
 181     if (!cos)
 182     {
 183         if (IsInteractive(cis))
 184             cos = DupFH(cis, FMF_WRITE, DOSBase);
 185         else
 186             cos = Open("*", FMF_WRITE);
 187 ;
 188         if (!cos) goto end;
 189
 190         cos_opened = TRUE;
 191     }
 192     else
 193     if (cos == (BPTR)SYS_DupStream)
 194     {
 195         cos = DupFH(Output(), FMF_WRITE, DOSBase);
 196         if (!cos) goto end;
 197
 198         cos_opened = TRUE;
 199     }
 200
 201     if (!ces)
 202     {
 203         if (IsInteractive(cis))
 204             ces = DupFH(cos, FMF_WRITE, DOSBase);
 205         else
 206             ces = Open("*", FMF_WRITE);
 207
 208         if (!ces) goto end;
 209
 210         ces_opened = TRUE;
 211     }
 212     else
 213     if (ces == (BPTR)SYS_DupStream)
 214     {
 215         ces = DupFH(Output(), FMF_WRITE, DOSBase);
 216         if (!ces) goto end;
 217
 218         ces_opened = TRUE;
 219     }
 220
 221     /* Load the shell */
 222 #warning implement UserShell and BootShell
 223     shellseg = LoadSeg("C:Shell");
 224     if (!shellseg)
 225         goto end;
 226
 227     newtags = CloneTagItems(tags);
 228     if (newtags)
 229     {
 230         struct CliStartupMessage csm;
 231         struct Process *me       = (struct Process *)FindTask(NULL);
 232         struct Process *cliproc;
 233
 234         struct TagItem proctags[] =
 235         {
 236             { NP_Entry      , (IPTR) NewCliProc             }, /* 0  */
 237             { NP_Priority   , me->pr_Task.tc_Node.ln_Pri    }, /* 1  */
 238
 239             /*
 240                 Disabled, because CreateNewProc() already handles NP_StackSize,
 241                 i.e. it uses either AROS_STACKSIZE or the stack from the parent
 242                 process.
 243             */
 244             // { NP_StackSize  , AROS_STACKSIZE                },
 245             { TAG_IGNORE    , 0                             }, /* 2  */
 246             { NP_Name       , isBoot ? (IPTR)"Boot Shell" :
 247                               isBackground ?
 248                               (IPTR)"Background CLI" :
 249                               (IPTR)"New Shell"             }, /* 3  */
 250             { NP_Input      , (IPTR)cis                     }, /* 4  */
 251             { NP_Output     , (IPTR)cos                     }, /* 5  */
 252             { NP_CloseInput , (isAsynch || cis_opened)      }, /* 6  */
 253             { NP_CloseOutput, (isAsynch || cos_opened)      }, /* 7  */
 254             { NP_Cli        , (IPTR)TRUE                    }, /* 8  */
 255             { NP_WindowPtr  , isAsynch ? (IPTR)NULL :
 256                               (IPTR)me->pr_WindowPtr        }, /* 9 */
 257             { NP_Arguments  , (IPTR)command                 }, /* 10 */
 258             { NP_Synchronous, FALSE                         }, /* 11 */
 259             { NP_Error      , (IPTR)ces                     }, /* 12 */
 260             { NP_CloseError , (isAsynch || ces_opened) &&
 261             /*
 262                 Since old AmigaOS programs don't know anything about Error()
 263                 being handled by this function, don't close the Error stream
 264                 if it's the same as the caller's one.
 265             */
 266                               ces != Error()                }, /* 13 */
 267             { TAG_END       , 0                             }  /* 14 */
 268         };
 269
 270         Tag filterList[] =
 271         {
 272             NP_Seglist,
 273             NP_FreeSeglist,
 274             NP_Entry,
 275             NP_Input,
 276             NP_Output,
 277             NP_CloseInput,
 278             NP_CloseOutput,
 279             NP_CloseError,
 280             NP_HomeDir,
 281             NP_Cli,
 282             0
 283         };
 284
 285         FilterTagItems(newtags, filterList, TAGFILTER_NOT);
 286
 287         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Tag  = TAG_MORE;
 288         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Data = (IPTR)newtags;
 289
 290         cliproc = CreateNewProc(proctags);
 291
 292         if (cliproc)
 293         {
 294             csm.csm_Msg.mn_Node.ln_Type = NT_MESSAGE;
 295             csm.csm_Msg.mn_Length       = sizeof(csm);
 296             csm.csm_Msg.mn_ReplyPort    = &me->pr_MsgPort;
 297
 298             csm.csm_CurrentInput = script;
 299             csm.csm_ShellSeg     = shellseg;
 300             csm.csm_Background   = isBackground;
 301             csm.csm_Asynch       = isAsynch;
 302
 303             PutMsg(&cliproc->pr_MsgPort, (struct Message *)&csm);
 304             WaitPort(&me->pr_MsgPort);
 305             GetMsg(&me->pr_MsgPort);
 306
 307             if (cliNumPtr) *cliNumPtr = csm.csm_CliNumber;
 308
 309             rc = csm.csm_ReturnCode;
 310
 311             script_opened =
 312             cis_opened    =
 313             cos_opened    =
 314             ces_opened    = FALSE;
 315
 316             shellseg = NULL;
 317         }
 318         FreeTagItems(newtags);
 319     }
 320
 321 end:
 322     UnLoadSeg(shellseg);
 323     if (script_opened) Close(script);
 324     if (cis_opened)    Close(cis);
 325     if (cos_opened)    Close(cos);
 326     if (ces_opened)    Close(ces);
 327
 328     return rc;
 329
 330     AROS_LIBFUNC_EXIT
 331 } /* SystemTagList */
 332
 333 static BPTR DupFH(BPTR fh, LONG mode, struct DosLibrary * DOSBase)
 334 {
 335     BPTR ret = NULL;
 336
 337     if (fh)
 338     {
 339         BPTR olddir = CurrentDir(fh);
 340         ret    = Open("", mode);
 341
 342         CurrentDir(olddir);
 343     }
 344
 345     return ret;
 346 }