compiler/clib/system.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     ANSI C function system().
   6 */
   7
   8 #include "__arosc_privdata.h"
   9
  10 #include <dos/dos.h>
  11 #include <dos/filesystem.h>
  12 #include <proto/dos.h>
  13 #include <utility/tagitem.h>
  14 #include <unistd.h>
  15
  16 #include "__errno.h"
  17 #include "__open.h"
  18 #include "__spawnv.h"
  19 #include "__upath.h"
  20 #include <process.h>
  21
  22 #define DEBUG 0
  23 #include <aros/debug.h>
  24
  25 /* defined in __spawnv.c */
  26 AROS_UFP3(extern LONG, wait_entry,
  27 AROS_UFPA(char *, argstr,A0),
  28 AROS_UFPA(ULONG, argsize,D0),
  29 AROS_UFPA(struct ExecBase *,SysBase,A6));
  30
  31 extern BPTR DupFHFromfd(int fd, ULONG mode);
  32
  33 static void syncFilePos(int from_fd, BPTR to_fh)
  34 {
  35    fdesc *desc;
  36    BPTR fh;
  37    LONG offset;
  38
  39    desc = __getfdesc(from_fd);
  40    if (desc)
  41    {
  42         fh = (BPTR)(desc->fh);
  43         Flush(fh);
  44         offset = Seek(fh, 0, OFFSET_CURRENT);
  45
  46         if (offset > 0)
  47             if (Seek(to_fh, offset, OFFSET_BEGINNING) < 0)
  48                 D(bug("system: Seek error: %d\n", IoErr()));
  49    }
  50 }
  51
  52 static void syncFilePosBack(BPTR from_fh, int to_fd)
  53 {
  54    fdesc *desc;
  55    BPTR fh;
  56    LONG offset;
  57
  58    desc = __getfdesc(to_fd);
  59    if (desc)
  60    {
  61         fh = (BPTR)(desc->fh);
  62         Flush(fh);
  63         offset = Seek(from_fh, 0, OFFSET_CURRENT);
  64
  65         if (offset > 0)
  66             if (Seek(fh, offset, OFFSET_BEGINNING) < 0)
  67                 D(bug("system: Seek error: %d\n", IoErr()));
  68    }
  69 }
  70
  71 /*****************************************************************************
  72
  73     NAME */
  74 #include <stdlib.h>
  75
  76         int system (
  77
  78 /*  SYNOPSIS */
  79         const char *string)
  80
  81 /*  FUNCTION
  82
  83     INPUTS
  84
  85     RESULT
  86
  87     NOTES
  88
  89     EXAMPLE
  90
  91     BUGS
  92
  93     SEE ALSO
  94
  95     INTERNALS
  96
  97 ******************************************************************************/
  98 {
  99     CONST_STRPTR apath;
 100     char *args, *cmd;
 101     BPTR seg;
 102     int ret;
 103
 104     if (string == NULL || string[0] == '\0')
 105     {
 106         D(bug("system(cmd=, args=)=1\n"));
 107         return 1;
 108     }
 109
 110     cmd = strdup(string);
 111     args = cmd;
 112
 113     while (++args)
 114     {
 115         switch (args[0])
 116         {
 117         case ' ':
 118         case '\t':
 119         case '\n':
 120             args[0] = '\0';
 121             break;
 122         case '\0':
 123             args = NULL;
 124             break;
 125         }
 126
 127         if (!args)
 128             break;
 129
 130         if (args[0] == '\0')
 131         {
 132             ++args;
 133             break;
 134         }
 135     }
 136
 137     D(bug("system(cmd=%s, args=%s)\n", cmd, args ? args : ""));
 138
 139     apath = __path_u2a(cmd);
 140     seg = LoadSeg(apath);
 141     if (seg == MKBADDR(NULL))
 142     {
 143         struct CommandLineInterface *cli = Cli();
 144         BPTR oldCurDir = CurrentDir(NULL);
 145         BPTR *paths = cli ? BADDR(cli->cli_CommandDir) : NULL;
 146
 147         for (; seg == MKBADDR(NULL) && paths; paths = BADDR(paths[0]))
 148         {
 149             CurrentDir(paths[1]);
 150             seg = LoadSeg(apath);
 151         }
 152
 153         if (seg == MKBADDR(NULL))
 154         {
 155             errno = IoErr2errno(IoErr());
 156             D(bug("system(cmd=%s, args=%s)=-1, errno=%d\n",
 157                   cmd, args ? args : "", errno));
 158             CurrentDir(oldCurDir);
 159             free(cmd);
 160             return -1;
 161         }
 162         else
 163             errno = 0;
 164
 165         CurrentDir(oldCurDir);
 166     }
 167     else
 168         errno = 0;
 169
 170     {
 171         BPTR in, out, err;
 172         childdata_t childdata;
 173
 174         struct TagItem tags[] =
 175         {
 176             { NP_Entry,       (IPTR)wait_entry },
 177             { NP_Input,       0                }, /* 1 */
 178             { NP_Output,      0                }, /* 2 */
 179             { NP_Error,       0                }, /* 3 */
 180             { NP_Arguments,   (IPTR)args       }, /* 4 */
 181             { NP_CloseInput,  FALSE            },
 182             { NP_CloseOutput, FALSE            },
 183             { NP_CloseError,  FALSE            },
 184             { NP_FreeSeglist, FALSE            },
 185             { NP_Cli,         TRUE             },
 186             { NP_Synchronous, TRUE             },
 187             { NP_Name,        (IPTR)cmd        },
 188             { NP_UserData,    (IPTR)&childdata },
 189             { TAG_DONE,       0                }
 190         };
 191
 192         childdata.command = seg;
 193
 194         in  = DupFHFromfd(STDIN_FILENO,  FMF_READ);
 195         out = DupFHFromfd(STDOUT_FILENO, FMF_WRITE);
 196         err = DupFHFromfd(STDERR_FILENO, FMF_WRITE);
 197
 198         /* isnt the responsability of DupFH/DupLock/Open(""/Lock(""
 199            to keep files pointers in sync ???
 200            or better, the filesystem ??? */
 201         if (in)
 202         {
 203             tags[1].ti_Data = (IPTR)in;
 204             syncFilePos(STDIN_FILENO, in);
 205         }
 206         else
 207             tags[1].ti_Tag  = TAG_IGNORE;
 208
 209         if (in)
 210         {
 211             tags[2].ti_Data = (IPTR)out;
 212             syncFilePos(STDOUT_FILENO, out);
 213         }
 214         else
 215             tags[2].ti_Tag  = TAG_IGNORE;
 216
 217         if (in)
 218         {
 219             tags[3].ti_Data = (IPTR)err;
 220             syncFilePos(STDERR_FILENO, err);
 221         }
 222         else
 223             tags[3].ti_Tag  = TAG_IGNORE;
 224
 225         childdata.parent_does_upath = __doupath;
 226
 227         if (CreateNewProc(tags) != NULL)
 228             ret = childdata.returncode;
 229         else
 230         {
 231             ret = -1;
 232             errno = IoErr2errno(IoErr());
 233         }
 234
 235         UnLoadSeg(seg);
 236
 237         if (in)
 238         {
 239             syncFilePosBack(in, STDIN_FILENO);
 240             Close(in);
 241         }
 242
 243         if (out)
 244         {
 245             syncFilePosBack(out, STDOUT_FILENO);
 246             Close(out);
 247         }
 248
 249         if (err)
 250         {
 251             syncFilePosBack(err, STDERR_FILENO);
 252             Close(err);
 253         }
 254     }
 255
 256     D(bug("system(cmd=%s, args=%s)=%d, errno=%d\n",
 257           cmd, args ? args : "", ret, errno));
 258     free(cmd);
 259     return ret;
 260 } /* system */
 261