workbench/c/shellcommands/Execute.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang:
   7 */
   8
   9 /******************************************************************************
  10
  11     NAME
  12
  13         Execute <script> [{<arguments>}]
  14
  15     SYNOPSIS
  16
  17         FILE/A
  18
  19     LOCATION
  20
  21         C:
  22
  23     FUNCTION
  24
  25         Executes a script with DOS commands.
  26
  27     INPUTS
  28
  29         FILE -- file to execute
  30
  31     RESULT
  32
  33     NOTES
  34
  35     EXAMPLE
  36
  37     BUGS
  38
  39     SEE ALSO
  40
  41     INTERNALS
  42
  43     HISTORY
  44
  45 ******************************************************************************/
  46
  47 #include <proto/exec.h>
  48 #include <dos/dos.h>
  49 #include <dos/bptr.h>
  50 #include <dos/stdio.h>
  51 #include <proto/dos.h>
  52 #include <proto/alib.h>
  53 #include <string.h>
  54
  55 #define DEBUG 0
  56 #include <aros/debug.h>
  57
  58 #ifndef USE_EMBEDDED_COMMANDS
  59 #define SH_GLOBAL_SYSBASE       1       /* For __sprintf */
  60 #endif
  61 #include <aros/shcommands.h>
  62
  63 AROS_SH2(Execute, 41.1,
  64 AROS_SHA(STRPTR, ,NAME     , /A, NULL),
  65 AROS_SHA(STRPTR, ,ARGUMENTS, /F, NULL))
  66 {
  67     AROS_SHCOMMAND_INIT
  68
  69     struct CommandLineInterface *cli = Cli();
  70     STRPTR arguments = SHArg(ARGUMENTS), s;
  71     STRPTR extraargs = NULL;
  72     BPTR from;
  73     LONG len;
  74     BPTR ces;
  75     struct Process *me = (struct Process *)FindTask(NULL);
  76
  77     if (!cli)
  78         return RETURN_ERROR;
  79
  80     /* pr_CES can be NULL, so use pr_COS */
  81     if(! (ces=me->pr_CES))
  82         ces=me->pr_COS;
  83
  84     if (! arguments)
  85         arguments = "";
  86
  87     /* See if we have extra arguments buffered in Input()
  88      */
  89     if (Input() != BNULL) {
  90         struct FileHandle *fh = BADDR(Input());
  91
  92         if (fh->fh_Pos > 0 && fh->fh_End > 0) {
  93             LONG extraargsize = fh->fh_End - fh->fh_Pos;
  94
  95             if (extraargsize > 0) {
  96                 LONG argsize = strlen(arguments);
  97                 extraargs = AllocVec(argsize + 1 + extraargsize + 1, MEMF_ANY);
  98                 if (extraargs) {
  99                     CopyMem(arguments, extraargs, argsize);
 100                     extraargs[argsize++] = '\n';
 101                     CopyMem(BADDR(fh->fh_Buf)+fh->fh_Pos, &extraargs[argsize], extraargsize);
 102                     argsize += extraargsize;
 103                     extraargs[argsize++] = 0;
 104                     arguments = extraargs;
 105                 }
 106             }
 107         }
 108     }
 109
 110     from = Open(SHArg(NAME), MODE_OLDFILE);
 111
 112     if (!from)
 113     {
 114         IPTR data[] = { (IPTR)SHArg(NAME) };
 115         VFPrintf(ces, "EXECUTE: can't open %s\n", data);
 116         PrintFault(IoErr(), NULL);
 117         if (extraargs)
 118             FreeVec(extraargs);
 119         return RETURN_FAIL;
 120     }
 121
 122     if (cli->cli_StandardInput == cli->cli_CurrentInput)
 123     {
 124         cli->cli_CurrentInput = from;
 125     }
 126     else
 127     {
 128         struct DateStamp ds;
 129         BYTE tmpname[256];
 130         BPTR tmpfile = BNULL;
 131         ULONG count = 0;
 132         BYTE tmpdir[4];
 133         BPTR tmplock;
 134         struct Window *win;
 135         struct Process *proc = (struct Process*)FindTask(0);
 136
 137         DateStamp(&ds);
 138
 139         win = proc->pr_WindowPtr;
 140         proc->pr_WindowPtr = (struct Window *)-1;
 141         tmplock = Lock("T:", SHARED_LOCK);
 142         proc->pr_WindowPtr = win;
 143         if (tmplock) {
 144             strcpy(tmpdir, "T:");
 145             UnLock(tmplock);
 146         } else {
 147             strcpy(tmpdir, ":T/");
 148         }
 149
 150         do {
 151             count++;
 152             __sprintf(tmpname, "%sTmp%lu%lu%lu%lu%lu", tmpdir,
 153                       ((struct Process *)FindTask(NULL))->pr_TaskNum,
 154                       ds.ds_Days, ds.ds_Minute, ds.ds_Tick, count);
 155             tmpfile = Open(tmpname, MODE_NEWFILE);
 156         } while (tmpfile == BNULL && IoErr() == ERROR_OBJECT_IN_USE);
 157
 158         if (tmpfile)
 159         {
 160             LONG c;
 161
 162             //if (FPuts(tmpfile, ".pushis\n") != -1)
 163                 while((c = FGetC(from)) != -1 && FPutC(tmpfile, c) != -1);
 164
 165             c = IoErr();
 166             Close(from);
 167
 168             if (c)
 169             {
 170                 FPuts(ces, "EXECUTE: error while creating temporary file\n");
 171                 PrintFault(c, NULL);
 172                 Close(tmpfile);
 173                 DeleteFile(tmpname);
 174                 if (extraargs)
 175                     FreeVec(extraargs);
 176
 177                 return RETURN_FAIL;
 178             }
 179
 180             c = '\n';
 181             FPutC(tmpfile, c);
 182
 183             //FPuts(tmpfile, ".popis\n");
 184
 185             while((c = FGetC(cli->cli_CurrentInput)) != -1 && FPutC(tmpfile, c) != -1);
 186
 187             c = IoErr();
 188
 189             if (c)
 190             {
 191                 FPuts(ces, "EXECUTE: error while creating temporary file\n");
 192                 PrintFault(c, NULL);
 193                 Close(tmpfile);
 194                 DeleteFile(tmpname);
 195                 if (extraargs)
 196                     FreeVec(extraargs);
 197
 198                 return RETURN_FAIL;
 199             }
 200
 201             Close(cli->cli_CurrentInput);
 202             if (AROS_BSTR_strlen(cli->cli_CommandFile))
 203                 DeleteFile(AROS_BSTR_ADDR(cli->cli_CommandFile));
 204
 205             {
 206                 LONG len = strlen(tmpname);
 207                 CopyMem(tmpname, AROS_BSTR_ADDR(cli->cli_CommandFile), len);
 208                 AROS_BSTR_setstrlen(cli->cli_CommandFile, len);
 209             }
 210
 211             cli->cli_CurrentInput = tmpfile;
 212             Seek(tmpfile, 0, OFFSET_BEGINNING);
 213         }
 214         else
 215         {
 216             /*
 217               we should try to open ":T", but since ":"
 218               is not handled correctly yet, we just give up
 219             */
 220             LONG c = IoErr();
 221             FPuts(ces, "EXECUTE: error while creating temporary file\n");
 222             PrintFault(c, NULL);
 223             Close(from);
 224             if (extraargs)
 225                 FreeVec(extraargs);
 226
 227             return RETURN_FAIL;
 228         }
 229     }
 230
 231     /* Update cli_CommandName to be the name of the script */
 232     len = strlen(SHArg(NAME));
 233     s = AROS_BSTR_ADDR(cli->cli_CommandName);
 234     AROS_BSTR_setstrlen(cli->cli_CommandName, len);
 235     CopyMem(SHArg(NAME), s, len);
 236
 237     if (arguments && strlen(arguments)) {
 238         struct FileHandle *fh;
 239         TEXT *fh_buff;
 240
 241         len = strlen(arguments);
 242
 243         /* Inject the command args into cli->cli_StandardInput
 244          *
 245          * It would be nice to have a standard DOS LVO that
 246          * could do this for us.
 247          */
 248         Flush(cli->cli_StandardInput);
 249         if (SetVBuf(cli->cli_StandardInput, NULL, BUF_LINE, len + 1) == 0) {
 250             fh = BADDR(cli->cli_StandardInput);
 251             fh->fh_Pos = 0;
 252             fh->fh_End = len + 1;
 253             fh_buff = BADDR(fh->fh_Buf);
 254             CopyMem(arguments, fh_buff, len);
 255             fh_buff[len] = '\n';
 256             /* Prevent RunCommand() from flushing cli_StandardInput */
 257             SelectInput(BNULL);
 258         } else {
 259             VFPrintf(ces, "EXECUTE: Can't inject command line\n", NULL);
 260             return RETURN_FAIL;
 261         }
 262     }
 263
 264     return RETURN_OK;
 265
 266     AROS_SHCOMMAND_EXIT
 267 }