rom/dos/systemtaglist.c

   1 /*
   2     Copyright © 1995-2001, 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     AROS_LIBBASE_EXT_DECL(struct DosLibrary *, DOSBase)
 106
 107     BPTR   cis = Input(), cos = Output(), ces = Error(), script = NULL;
 108     BPTR   shellseg = NULL;
 109     STRPTR cShell   = NULL;
 110     BOOL script_opened = FALSE;
 111     BOOL cis_opened    = FALSE;
 112     BOOL cos_opened    = FALSE;
 113     BOOL ces_opened    = FALSE;
 114     BOOL isBoot        = TRUE;
 115     BOOL isBackground  = TRUE;
 116     BOOL isAsynch      = FALSE;
 117     LONG rc            = -1;
 118     LONG *cliNumPtr    = NULL;
 119
 120     struct TagItem *newtags, *tags2 = tags, *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;
 152                 break;
 153
 154             case SYS_Asynch:
 155                 isAsynch = tag->ti_Data;
 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             { NP_StackSize  , AROS_STACKSIZE                }, /* 2  */
 239             { NP_Name       , isBoot ? (IPTR)"Boot Shell" :
 240                               isBackground ?
 241                               (IPTR)"Background CLI" :
 242                               (IPTR)"New Shell"             }, /* 3  */
 243             { NP_Input      , (IPTR)cis                     }, /* 4  */
 244             { NP_Output     , (IPTR)cos                     }, /* 5  */
 245             { NP_CloseInput , (isAsynch || cis_opened)      }, /* 6  */
 246             { NP_CloseOutput, (isAsynch || cos_opened)      }, /* 7  */
 247             { NP_Cli        , (IPTR)TRUE                    }, /* 8  */
 248             { NP_WindowPtr  , isAsynch ? (IPTR)NULL :
 249                               (IPTR)me->pr_WindowPtr        }, /* 9 */
 250             { NP_Arguments  , (IPTR)command                 }, /* 10 */
 251             { NP_Synchronous, FALSE                         }, /* 11 */
 252             { NP_Error      , (IPTR)ces                     }, /* 12 */
 253             { NP_CloseError , (isAsynch || ces_opened) &&
 254             /*
 255                 Since old AmigaOS programs don't know anything about Error()
 256                 being handled by this function, don't close the Error stream
 257                 if it's the same as the caller's one.
 258             */
 259                               ces != Error()                }, /* 13 */
 260             { TAG_END       , 0                             }  /* 14 */
 261         };
 262
 263         Tag filterList[] =
 264         {
 265             NP_Seglist,
 266             NP_FreeSeglist,
 267             NP_Entry,
 268             NP_Input,
 269             NP_Output,
 270             NP_CloseInput,
 271             NP_CloseOutput,
 272             NP_CloseError,
 273             NP_HomeDir,
 274             NP_Cli,
 275             NULL
 276         };
 277
 278         FilterTagItems(newtags, filterList, TAGFILTER_NOT);
 279
 280         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Tag  = TAG_MORE;
 281         proctags[sizeof(proctags)/(sizeof(proctags[0])) - 1].ti_Data = (IPTR)newtags;
 282
 283         cliproc = CreateNewProc(proctags);
 284
 285         if (cliproc)
 286         {
 287             csm.csm_Msg.mn_Node.ln_Type = NT_MESSAGE;
 288             csm.csm_Msg.mn_Length       = sizeof(csm);
 289             csm.csm_Msg.mn_ReplyPort    = &me->pr_MsgPort;
 290
 291             csm.csm_CurrentInput = script;
 292             csm.csm_ShellSeg     = shellseg;
 293             csm.csm_Background   = isBackground;
 294             csm.csm_Asynch       = isAsynch;
 295
 296             PutMsg(&cliproc->pr_MsgPort, (struct Message *)&csm);
 297             WaitPort(&me->pr_MsgPort);
 298             GetMsg(&me->pr_MsgPort);
 299
 300             if (cliNumPtr) *cliNumPtr = csm.csm_CliNumber;
 301
 302             rc = csm.csm_ReturnCode;
 303
 304             script_opened =
 305             cis_opened    =
 306             cos_opened    =
 307             ces_opened    = FALSE;
 308
 309             shellseg = NULL;
 310         }
 311         FreeTagItems(newtags);
 312     }
 313
 314 end:
 315     UnLoadSeg(shellseg);
 316     if (script_opened) Close(script);
 317     if (cis_opened)    Close(cis);
 318     if (cos_opened)    Close(cos);
 319     if (ces_opened)    Close(ces);
 320
 321     return rc;
 322
 323     AROS_LIBFUNC_EXIT
 324 } /* SystemTagList */
 325
 326 static BPTR DupFH(BPTR fh, LONG mode, struct DosLibrary * DOSBase)
 327 {
 328     BPTR ret = NULL;
 329
 330     if (fh)
 331     {
 332         BPTR olddir = CurrentDir(fh);
 333         ret    = Open("", mode);
 334
 335         CurrentDir(olddir);
 336     }
 337
 338     return ret;
 339 }