WebSVN – SvarDOS – Diff – /svarcom/trunk/redir.c


/* This file is part of the SvarCOM project and is published under the terms
 * of the MIT license.
 *
 * Copyright (C) 2021 Mateusz Viste
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#include <string.h> /* memset() */
 
#include "doserr.h"
#include "helpers.h"
#include "rmodinit.h"
 
#include "redir.h"
 
static unsigned short oldstdout = 0xffff;
 
 
/* parse commandline and performs necessary redirections. cmdline is
 * modified so all redirections are cut out. */
void redir_parsecmd(struct redir_data *d, char *cmdline) {
  unsigned short i;
  unsigned short pipescount = 0;
 
  /* NOTE:
   *
   * 1. while it is possible to type a command with multiple
   *    redirections, MSDOS executes only the last redirection.
   *
   * 2. the order in which >, < and | are provided on the command line does
   *    not seem to matter for MSDOS. piped commands are executed first (in
   *    the order they appear) and the result of the last one is redirected to
   *    whenever the last > points at.
   */
 
  /* preset oldstdout to 0xffff in case no redirection is required */
  oldstdout = 0xffff;
 
  /* clear out the redir_data struct */
  memset(d, 0, sizeof(*d));
 
  /* parse the command line and fill struct with pointers */
  for (i = 0;; i++) {
    if (cmdline[i] == '>') {
      cmdline[i] = 0;
      if (cmdline[i + 1] == '>') {
        i++;
        d->stdout_openflag = 0x11;  /* used during int 21h,AH=6C */
      } else {
        d->stdout_openflag = 0x12;
      }
      d->stdoutfile = cmdline + i + 1;
      while (d->stdoutfile[0] == ' ') d->stdoutfile++;
    } else if (cmdline[i] == '<') {
      cmdline[i] = 0;
      d->stdinfile = cmdline + i + 1;
      while (d->stdinfile[0] == ' ') d->stdinfile++;
    } else if (cmdline[i] == '|') {
      cmdline[i] = 0;
      if (pipescount < REDIR_MAX_PIPES) {
        d->pipes[pipescount++] = cmdline + i + 1;
        while (d->pipes[pipescount][0] == ' ') d->pipes[pipescount]++;
      }
    } else if (cmdline[i] == 0) {
      break;
    }
  }
}
 
 
/* apply stdin/stdout redirections defined in redir_data, returns 0 on success */
int redir_apply(const struct redir_data *d) {
  if (d->stdinfile != NULL) {
    outputnl("ERROR: stdin redirection is not supported yet");
    return(-1);
  }
 
  if (d->stdoutfile != NULL) {
    unsigned short openflag = d->stdout_openflag;
    unsigned short errcode = 0;
    unsigned short handle = 0;
    const char *myptr = d->stdoutfile;
 
    /* */
    _asm {
      push ax
      push bx
      push cx
      push dx
      push si
      mov ax, 0x6c00     /* Extended Open/Create */
      mov bx, 1          /* access mode (0=read, 1=write, 2=r+w */
      xor cx, cx         /* attributes when(if) creating the file (0=normal) */
      mov dx, [openflag] /* action if file exists (0x11=open, 0x12=truncate)*/
      mov si, myptr      /* ASCIIZ filename */
      int 0x21           /* AX=handle on success (CF clear), otherwise dos err */
      mov handle, ax     /* save the file handler */
      jnc JMPEOF
      mov errcode, ax
      jmp DONE
 
      JMPEOF:
      cmp openflag, word ptr 0x11
      jne DUPSTDOUT
      /* jump to the end of the file (required for >> redirections) */
      mov ax, 0x4202     /* jump to position EOF - CX:DX in handle BX */
      mov bx, handle
      xor cx, cx
      xor dx, dx
      int 0x21
 
      /* save (duplicate) current stdout so I can revert it later */
      DUPSTDOUT:
      mov ah, 0x45       /* duplicate file handle */
      mov bx, 1          /* handle to dup (1=stdout) */
      int 0x21           /* ax = new file handle */
      mov oldstdout, ax
      /* redirect the stdout handle */
      mov bx, handle     /* dst handle */
      mov cx, 1          /* src handle (1=stdout) */
      mov ah, 0x46       /* redirect a handle */
      int 0x21
      /* close the original file handle (no longer needed) */
      mov ah, 0x3e       /* close a file handle (handle in BX) */
      int 0x21
      DONE:
      pop si
      pop dx
      pop cx
      pop bx
      pop ax
    }
    if (errcode != 0) {
      outputnl(doserr(errcode));
      return(-1);
    }
  }
 
  return(0);
}
 
 
/* restores previous stdout/stdin handlers if they have been redirected */
void redir_revert(void) {
  _asm {
    /* if oldstdout is 0xffff then not redirected */
    cmp word ptr [oldstdout], 0xffff
    je DONE
    /* redirect the stdout handle */
    mov bx, [oldstdout] /* dst handle */
    mov cx, 1           /* src handle (1=stdout) */
    mov ah, 0x46        /* redirect a handle */
    int 0x21
    /* close old handle (in bx already) */
    mov ah, 0x3e
    int 0x21
    mov [oldstdout], 0xffff
    DONE:
  }
}
 

Rev 519	Rev 520
1	`/* This file is part of the SvarCOM project and is published under the terms`	1	`/* This file is part of the SvarCOM project and is published under the terms`
2	`* of the MIT license.`	2	`* of the MIT license.`
3	`*`	3	`*`
4	`* Copyright (C) 2021 Mateusz Viste`	4	`* Copyright (C) 2021 Mateusz Viste`
5	`*`	5	`*`
6	`* Permission is hereby granted, free of charge, to any person obtaining a`	6	`* Permission is hereby granted, free of charge, to any person obtaining a`
7	`* copy of this software and associated documentation files (the "Software"),`	7	`* copy of this software and associated documentation files (the "Software"),`
8	`* to deal in the Software without restriction, including without limitation`	8	`* to deal in the Software without restriction, including without limitation`
9	`* the rights to use, copy, modify, merge, publish, distribute, sublicense,`	9	`* the rights to use, copy, modify, merge, publish, distribute, sublicense,`
10	`* and/or sell copies of the Software, and to permit persons to whom the`	10	`* and/or sell copies of the Software, and to permit persons to whom the`
11	`* Software is furnished to do so, subject to the following conditions:`	11	`* Software is furnished to do so, subject to the following conditions:`
12	`*`	12	`*`
13	`* The above copyright notice and this permission notice shall be included in`	13	`* The above copyright notice and this permission notice shall be included in`
14	`* all copies or substantial portions of the Software.`	14	`* all copies or substantial portions of the Software.`
15	`*`	15	`*`
16	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`	16	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`
17	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`	17	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`
18	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`	18	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`
19	`* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`	19	`* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER`
20	`* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING`	20	`* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING`
21	`* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER`	21	`* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER`
22	`* DEALINGS IN THE SOFTWARE.`	22	`* DEALINGS IN THE SOFTWARE.`
23	`*/`	23	`*/`
24		24
25	`#include <string.h> /* memset() */`	25	`#include <string.h> /* memset() */`
26		26
27	`#include "doserr.h"`	27	`#include "doserr.h"`
28	`#include "helpers.h"`	28	`#include "helpers.h"`
29	`#include "rmodinit.h"`	29	`#include "rmodinit.h"`
30		30
31	`#include "redir.h"`	31	`#include "redir.h"`
32		32
33	`static unsigned short oldstdout = 0xffff;`	33	`static unsigned short oldstdout = 0xffff;`
34		34
35		35
36	`/* parse commandline and performs necessary redirections. cmdline is`	36	`/* parse commandline and performs necessary redirections. cmdline is`
37	`* modified so all redirections are cut out. */`	37	`* modified so all redirections are cut out. */`
38	`void redir_parsecmd(struct redir_data d, char cmdline) {`	38	`void redir_parsecmd(struct redir_data d, char cmdline) {`
39	`unsigned short i;`	39	`unsigned short i;`
40	`unsigned short pipescount = 0;`	40	`unsigned short pipescount = 0;`
41		41
42	`/* NOTE:`	42	`/* NOTE:`
43	`*`	43	`*`
44	`* 1. while it is possible to type a command with multiple`	44	`* 1. while it is possible to type a command with multiple`
45	`* redirections, MSDOS executes only the last redirection.`	45	`* redirections, MSDOS executes only the last redirection.`
46	`*`	46	`*`
47	`* 2. the order in which >, < and \| are provided on the command line does`	47	`* 2. the order in which >, < and \| are provided on the command line does`
48	`* not seem to matter for MSDOS. piped commands are executed first (in`	48	`* not seem to matter for MSDOS. piped commands are executed first (in`
49	`* the order they appear) and the result of the last one is redirected to`	49	`* the order they appear) and the result of the last one is redirected to`
50	`* whenever the last > points at.`	50	`* whenever the last > points at.`
51	`*/`	51	`*/`
52		52
53	`/* preset oldstdout to 0xffff in case no redirection is required */`	53	`/* preset oldstdout to 0xffff in case no redirection is required */`
54	`oldstdout = 0xffff;`	54	`oldstdout = 0xffff;`
55		55
56	`/* clear out the redir_data struct */`	56	`/* clear out the redir_data struct */`
57	`memset(d, 0, sizeof(*d));`	57	`memset(d, 0, sizeof(*d));`
58		58
59	`/* parse the command line and fill struct with pointers */`	59	`/* parse the command line and fill struct with pointers */`
60	`for (i = 0;; i++) {`	60	`for (i = 0;; i++) {`
61	`if (cmdline[i] == '>') {`	61	`if (cmdline[i] == '>') {`
62	`cmdline[i] = 0;`	62	`cmdline[i] = 0;`
63	`if (cmdline[i + 1] == '>') {`	63	`if (cmdline[i + 1] == '>') {`
64	`i++;`	64	`i++;`
65	`d->stdout_openflag = 0x11; /* used during int 21h,AH=6C */`	65	`d->stdout_openflag = 0x11; /* used during int 21h,AH=6C */`
66	`} else {`	66	`} else {`
67	`d->stdout_openflag = 0x12;`	67	`d->stdout_openflag = 0x12;`
68	`}`	68	`}`
69	`d->stdoutfile = cmdline + i + 1;`	69	`d->stdoutfile = cmdline + i + 1;`
70	`while (d->stdoutfile[0] == ' ') d->stdoutfile++;`	70	`while (d->stdoutfile[0] == ' ') d->stdoutfile++;`
71	`} else if (cmdline[i] == '<') {`	71	`} else if (cmdline[i] == '<') {`
72	`cmdline[i] = 0;`	72	`cmdline[i] = 0;`
73	`d->stdinfile = cmdline + i + 1;`	73	`d->stdinfile = cmdline + i + 1;`
74	`while (d->stdinfile[0] == ' ') d->stdinfile++;`	74	`while (d->stdinfile[0] == ' ') d->stdinfile++;`
75	`} else if (cmdline[i] == '\|') {`	75	`} else if (cmdline[i] == '\|') {`
76	`cmdline[i] = 0;`	76	`cmdline[i] = 0;`
77	`if (pipescount < REDIR_MAX_PIPES) {`	77	`if (pipescount < REDIR_MAX_PIPES) {`
78	`d->pipes[pipescount++] = cmdline + i + 1;`	78	`d->pipes[pipescount++] = cmdline + i + 1;`
79	`while (d->pipes[pipescount][0] == ' ') d->pipes[pipescount]++;`	79	`while (d->pipes[pipescount][0] == ' ') d->pipes[pipescount]++;`
80	`}`	80	`}`
81	`} else if (cmdline[i] == 0) {`	81	`} else if (cmdline[i] == 0) {`
82	`break;`	82	`break;`
83	`}`	83	`}`
84	`}`	84	`}`
85	`}`	85	`}`
86		86
87		87
88	`/* apply stdin/stdout redirections defined in redir_data, returns 0 on success */`	88	`/* apply stdin/stdout redirections defined in redir_data, returns 0 on success */`
89	`int redir_apply(const struct redir_data *d) {`	89	`int redir_apply(const struct redir_data *d) {`
90	`if (d->stdinfile != NULL) {`	90	`if (d->stdinfile != NULL) {`
91	`outputnl("ERROR: stdin redirection is not supported yet");`	91	`outputnl("ERROR: stdin redirection is not supported yet");`
92	`return(-1);`	92	`return(-1);`
93	`}`	93	`}`
94		94
95	`if (d->stdoutfile != NULL) {`	95	`if (d->stdoutfile != NULL) {`
96	`unsigned short openflag = d->stdout_openflag;`	96	`unsigned short openflag = d->stdout_openflag;`
97	`unsigned short errcode = 0;`	97	`unsigned short errcode = 0;`
98	`unsigned short handle = 0;`	98	`unsigned short handle = 0;`
99	`const char *myptr = d->stdoutfile;`	99	`const char *myptr = d->stdoutfile;`
100		100
101	`/* */`	101	`/* */`
102	`_asm {`	102	`_asm {`
103	`push ax`	103	`push ax`
104	`push bx`	104	`push bx`
105	`push cx`	105	`push cx`
106	`push dx`	106	`push dx`
107	`push si`	107	`push si`
108	`mov ax, 0x6c00 /* Extended Open/Create */`	108	`mov ax, 0x6c00 /* Extended Open/Create */`
109	`mov bx, 1 /* access mode (0=read, 1=write, 2=r+w */`	109	`mov bx, 1 /* access mode (0=read, 1=write, 2=r+w */`
110	`xor cx, cx /* attributes when(if) creating the file (0=normal) */`	110	`xor cx, cx /* attributes when(if) creating the file (0=normal) */`
111	`mov dx, [openflag] /* action if file exists (0x11=open, 0x12=truncate)*/`	111	`mov dx, [openflag] /* action if file exists (0x11=open, 0x12=truncate)*/`
112	`mov si, myptr /* ASCIIZ filename */`	112	`mov si, myptr /* ASCIIZ filename */`
113	`int 0x21 /* AX=handle on success (CF clear), otherwise dos err */`	113	`int 0x21 /* AX=handle on success (CF clear), otherwise dos err */`
114	`mov [handle], ax /* save the file handler */`	114	`mov handle, ax /* save the file handler */`
115	`jnc DUPSTDOUT`	115	`jnc JMPEOF`
116	`mov [errcode], ax`	116	`mov errcode, ax`
117	`jmp DONE`	117	`jmp DONE`
-		118
-		119	`JMPEOF:`
-		120	`cmp openflag, word ptr 0x11`
118	`DUPSTDOUT:`	121	`jne DUPSTDOUT`
-		122	`/* jump to the end of the file (required for >> redirections) */`
-		123	`mov ax, 0x4202 /* jump to position EOF - CX:DX in handle BX */`
-		124	`mov bx, handle`
-		125	`xor cx, cx`
-		126	`xor dx, dx`
-		127	`int 0x21`
-		128
119	`/* save (duplicate) current stdout so I can revert it later */`	129	`/* save (duplicate) current stdout so I can revert it later */`
-		130	`DUPSTDOUT:`
120	`mov ah, 0x45 /* duplicate file handle */`	131	`mov ah, 0x45 /* duplicate file handle */`
121	`mov bx, 1 /* handle to dup (1=stdout) */`	132	`mov bx, 1 /* handle to dup (1=stdout) */`
122	`int 0x21 /* ax = new file handle */`	133	`int 0x21 /* ax = new file handle */`
123	`mov [oldstdout], ax`	134	`mov oldstdout, ax`
124	`/* redirect the stdout handle */`	135	`/* redirect the stdout handle */`
125	`mov bx, [handle] /* dst handle */`	136	`mov bx, handle /* dst handle */`
126	`mov cx, 1 /* src handle (1=stdout) */`	137	`mov cx, 1 /* src handle (1=stdout) */`
127	`mov ah, 0x46 /* redirect a handle */`	138	`mov ah, 0x46 /* redirect a handle */`
128	`int 0x21`	139	`int 0x21`
129	`/* close the original file handle (no longer needed) */`	140	`/* close the original file handle (no longer needed) */`
130	`mov ah, 0x3e /* close a file handle (handle in BX) */`	141	`mov ah, 0x3e /* close a file handle (handle in BX) */`
131	`int 0x21`	142	`int 0x21`
132	`DONE:`	143	`DONE:`
133	`pop si`	144	`pop si`
134	`pop dx`	145	`pop dx`
135	`pop cx`	146	`pop cx`
136	`pop bx`	147	`pop bx`
137	`pop ax`	148	`pop ax`
138	`}`	149	`}`
139	`if (errcode != 0) {`	150	`if (errcode != 0) {`
140	`outputnl(doserr(errcode));`	151	`outputnl(doserr(errcode));`
141	`return(-1);`	152	`return(-1);`
142	`}`	153	`}`
143	`}`	154	`}`
144		155
145	`return(0);`	156	`return(0);`
146	`}`	157	`}`
147		158
148		159
149	`/* restores previous stdout/stdin handlers if they have been redirected */`	160	`/* restores previous stdout/stdin handlers if they have been redirected */`
150	`void redir_revert(void) {`	161	`void redir_revert(void) {`
151	`_asm {`	162	`_asm {`
152	`/* if oldstdout is 0xffff then not redirected */`	163	`/* if oldstdout is 0xffff then not redirected */`
153	`cmp word ptr [oldstdout], 0xffff`	164	`cmp word ptr [oldstdout], 0xffff`
154	`je DONE`	165	`je DONE`
155	`/* redirect the stdout handle */`	166	`/* redirect the stdout handle */`
156	`mov bx, [oldstdout] /* dst handle */`	167	`mov bx, [oldstdout] /* dst handle */`
157	`mov cx, 1 /* src handle (1=stdout) */`	168	`mov cx, 1 /* src handle (1=stdout) */`
158	`mov ah, 0x46 /* redirect a handle */`	169	`mov ah, 0x46 /* redirect a handle */`
159	`int 0x21`	170	`int 0x21`
160	`/* close old handle (in bx already) */`	171	`/* close old handle (in bx already) */`
161	`mov ah, 0x3e`	172	`mov ah, 0x3e`
162	`int 0x21`	173	`int 0x21`
163	`mov [oldstdout], 0xffff`	174	`mov [oldstdout], 0xffff`
164	`DONE:`	175	`DONE:`
165	`}`	176	`}`
166	`}`	177	`}`
167		178

Subversion Repositories SvarDOS

(root)/svarcom/trunk/redir.c @ 1798 – Rev 519 → 520