workbench/c/shellcommands/Pipe.c

   1 /*
   2  * Copyright (C) 2012, The AROS Development Team.  All rights reserved.
   3  * Author: Jason S. McMullan <jason.mcmullan@gmail.com>
   4  *
   5  * Licensed under the AROS PUBLIC LICENSE (APL) Version 1.1
   6  */
   7 /******************************************************************************
   8
   9     NAME
  10
  11         Pipe <command>
  12
  13     SYNOPSIS
  14
  15         COMMAND/F
  16
  17     LOCATION
  18
  19        C:
  20
  21     FUNCTION
  22
  23         Uses the _pchar and _mchar environment variables to split
  24         the COMMAND into fragments.
  25
  26         Where _pchar is seen, the commands on either side are connected
  27         with a PIPE: from the left side's Output() to the right side's Input().
  28
  29         Where _mchar is seen, the commands are executed in sequence, with
  30         no PIPE: between them, and Input() and Output() comes from the
  31         terminal.
  32
  33     INPUTS
  34
  35         COMMAND -- the command to execute
  36
  37     RESULT
  38
  39     NOTES
  40
  41         The "_pchar" and "_mchar" environment variables are used to determine
  42         where to split the command, and what action to perform.
  43
  44     EXAMPLE
  45
  46         > set _pchar "|"
  47         > set _mchar ";"
  48         > echo Hello ; echo World
  49         Hello
  50         World
  51         > Type S:Startup-Sequence | Sort
  52
  53     BUGS
  54
  55         Note that _pchar and _mchar are limited to 2 characters - any
  56         additional characters will be silently ignored.
  57
  58     SEE ALSO
  59
  60     INTERNALS
  61
  62     HISTORY
  63
  64 ******************************************************************************/
  65
  66 #define DEBUG 0
  67
  68 #include <aros/debug.h>
  69 #include <exec/execbase.h>
  70 #include <exec/libraries.h>
  71 #include <proto/exec.h>
  72 #include <dos/dos.h>
  73 #include <proto/dos.h>
  74 #include <string.h>
  75 #include <aros/shcommands.h>
  76
  77 static inline STRPTR NextToken(STRPTR *pstr, CONST_STRPTR tok)
  78 {
  79     STRPTR str, ostr = *pstr;
  80     int toklen = strlen(tok);
  81
  82     if (*ostr == 0)
  83         return NULL;
  84
  85     for (str = ostr; *str; str++) {
  86         if (strncmp(str, tok, toklen) == 0) {
  87             *str = 0;
  88             str += strlen(tok);
  89             *pstr = str;
  90             return ostr;
  91         }
  92     }
  93
  94     /* Token not found? */
  95     *pstr = ostr + strlen(ostr);
  96     return ostr;
  97 }
  98
  99 static BOOL Pipe(struct Library *DOSBase, BPTR pipe[2])
 100 {
 101     pipe[1]=Open("PIPE:*", MODE_NEWFILE);
 102     if (pipe[1]) {
 103         TEXT buff[64];
 104         if (NameFromFH(pipe[1], buff, sizeof(buff)) != 0) {
 105             pipe[0] = Open(buff, MODE_OLDFILE);
 106             if (pipe[0])
 107                 return TRUE;
 108         }
 109         Close(pipe[1]);
 110     }
 111     return FALSE;
 112 }
 113
 114 static LONG pcharExecute(struct Library *DOSBase, STRPTR cmd, CONST_STRPTR pchar, BPTR in, BPTR out)
 115 {
 116     STRPTR leftcmd, rightcmd;
 117     BPTR pipe[2];
 118     TEXT buff[64];
 119     LONG ret = RETURN_FAIL;
 120
 121     leftcmd = NextToken(&cmd, pchar);
 122     if (!leftcmd)
 123         return RETURN_OK;
 124
 125     rightcmd = cmd;
 126     if (*rightcmd == 0) {
 127         /* No pipe character? */
 128         return SystemTags(leftcmd, SYS_Input, in, SYS_Output, out, TAG_END);
 129     }
 130
 131     if (Pipe(DOSBase, pipe)) {
 132         BPTR cis = OpenFromLock(DupLockFromFH(in));
 133
 134         struct TagItem tags[] = {
 135             { SYS_Input,        (IPTR)cis },
 136             { SYS_Output,       (IPTR)pipe[1] },
 137             { SYS_Asynch,       TRUE },
 138             { TAG_DONE,         0 }
 139         };
 140
 141         if (SystemTagList(leftcmd, tags) == -1) {
 142             PrintFault(IoErr(), leftcmd);
 143             Close(cis);
 144             Close(pipe[0]);
 145             Close(pipe[1]);
 146             return RETURN_FAIL;
 147         }
 148
 149         ret = pcharExecute(DOSBase, rightcmd, pchar, pipe[0], out);
 150         /* Flush pipe */
 151         while (FGets(pipe[0], buff, sizeof buff) != NULL);
 152         Close(pipe[0]);
 153     }
 154
 155     return ret;
 156 }
 157
 158
 159 AROS_SH1(Pipe, 41.1,
 160 AROS_SHA(STRPTR, , , /F,   ""))
 161 {
 162     AROS_SHCOMMAND_INIT
 163     CONST_STRPTR cmd = SHArg( );
 164     struct CommandLineInterface *cli = Cli();
 165
 166     TEXT pchar[3], mchar[3];
 167     LONG len, ret = RETURN_FAIL;
 168     STRPTR tcmd, subcmd, cp;
 169
 170     len = GetVar("_pchar", pchar, sizeof pchar, GVF_LOCAL_ONLY | LV_VAR);
 171     if (len <= 0)
 172         pchar[0] = 0;
 173     pchar[2] = 0;
 174
 175     len = GetVar("_mchar", mchar, sizeof mchar, GVF_LOCAL_ONLY | LV_VAR);
 176     if (len <= 0)
 177         mchar[0] = 0;
 178     mchar[2] = 0;
 179
 180     /* Tokenize by mchar, if needed */
 181     len = strlen(cmd) + 1;
 182     if ((tcmd = AllocVec(len, MEMF_ANY))) {
 183         CopyMem(cmd, tcmd, len);
 184         cp = tcmd;
 185
 186         for (subcmd = NextToken(&cp, mchar); subcmd; subcmd = NextToken(&cp, mchar)) {
 187             ret = pcharExecute((struct Library *)DOSBase, subcmd, pchar, Input(), Output());
 188             if (ret >= cli->cli_FailLevel)
 189                 break;
 190         }
 191
 192         FreeVec(tcmd);
 193     }
 194
 195     return ret;
 196     AROS_SHCOMMAND_EXIT
 197 }