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


/* This file is part of the SvarCOM project and is published under the terms
 * of the MIT license.
 *
 * Copyright (C) 2021-2022 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 <i86.h>
#include <string.h>
 
#include "env.h"
#include "helpers.h"
 
#include "rmodinit.h"
 
 
/* returns far pointer to rmod's settings block on success */
struct rmod_props far *rmod_install(unsigned short envsize, unsigned char *rmodcore, unsigned short rmodcore_len) {
  char far *myptr, far *mcb;
  unsigned short far *owner;
  const unsigned short sizeof_rmodandprops_paras = (0x100 + rmodcore_len + sizeof(struct rmod_props) + 15) / 16;
  unsigned short rmodseg = 0xffff;
  unsigned short envseg, origenvseg;
  struct rmod_props far *res;
 
  /* read my current env segment from PSP and save it */
  envseg = *((unsigned short *)0x2c);
  origenvseg = envseg;
 
  /* printf("original (PSP) env buffer at %04X\r\n", envseg); */
 
  /* if envseg is zero, then enforce our own one (MSDOS 5 does not provide a default env) */
  if ((envseg == 0) && (envsize == 0)) envsize = 256;
 
  /* if custom envsize requested, convert it to number of paragraphs */
  if (envsize != 0) {
    envsize += 15;
    envsize /= 16;
  }
 
  _asm {
    push bx
    push cx
    push dx
 
    /* link in the UMB memory chain for enabling high-memory allocation (and save initial status on stack) */
    mov ax, 0x5802  /* GET UMB LINK STATE */
    int 0x21
    xor ah, ah
    push ax         /* save link state on stack */
    mov ax, 0x5803  /* SET UMB LINK STATE */
    mov bx, 1
    int 0x21
    /* get current allocation strategy and save it in DX */
    mov ax, 0x5800
    int 0x21
    push ax
    pop dx
    /* set strategy to 'last fit, try high then low memory' */
    mov ax, 0x5801
    mov bx, 0x0082
    int 0x21
    /* ask for a memory block and save the given segment to rmodseg */
    mov ah, 0x48
    mov bx, sizeof_rmodandprops_paras
    int 0x21
    jc ALLOC_FAIL
    mov rmodseg, ax
    /* ask for a memory block for the environment and save it to envseg (only if custom size requested) */
    mov bx, envsize
    test bx, bx
    jz ALLOC_FAIL
    mov ah, 0x48
    int 0x21
    jc ALLOC_FAIL
    mov envseg, ax
 
    ALLOC_FAIL:
    /* restore initial allocation strategy */
    mov ax, 0x5801
    mov bx, dx
    int 0x21
    /* restore initial UMB memory link state */
    mov ax, 0x5803
    pop bx       /* pop initial UMB link state from stack */
    int 0x21
 
    pop dx
    pop cx
    pop bx
  }
 
  if (rmodseg == 0xffff) {
    outputnl("malloc error");
    return(NULL);
  }
 
  /* generate a new PSP where RMOD is about to land */
  _asm {
    push dx
    mov ah, 0x26 /* CREATE NEW PROGRAM SEGMENT PREFIX (DOS 1+) */
    mov dx, rmodseg
    int 0x21
    pop dx
  }
 
  myptr = MK_FP(rmodseg, 0);
 
  /* patch up RMOD's PSP: Parent's PSP segment @ 0x16-0x17 */
  myptr[0x16] = rmodseg & 0xff; /* RMOD is his own parent */
  myptr[0x17] = rmodseg >> 8;
 
  /* patch up RMOD's PSP: SS:SP pointer @ 0x2E-0x31  --  I abuse the PSP's
   * command line tail as stack, but I do NOT set the stack at the end of the
   * tail. E. C. Masloch kindly explained why this would be a bad idea:
   *
   * "This is wrong and will potentially overwrite part of your buffers that
   * start past the PSP. This is because the dword [PSP:2Eh] is not used merely
   * to set SS:SP but rather to find the stack frame created by the int 21h
   * call. Therefore the int 21h call that terminates the child process will
   * then pop a number of registers off starting from the address stored in the
   * PSP." <https://github.com/SvarDOS/bugz/issues/38#issuecomment-1817445740>
   */
  myptr[0x2e] = 192; /* middle of the command line tail area so I have 64 bytes */
  myptr[0x2f] = 0;   /* before and 64 bytes in front of me */
  myptr[0x30] = rmodseg & 0xff;
  myptr[0x31] = rmodseg >> 8;
 
  /* patch up RMOD's PSP: JFT size @ 0x32-0x33 */
  myptr[0x32] = 20; /* default JFT size (max that fits without an extra allocation) */
  myptr[0x33] = 0;
 
  /* patch up RMOD's PSP: JFT pointer @ 0x34-0x37 */
  myptr[0x34] = 0x18; /* the JFT is in the PSP itself */
  myptr[0x35] = 0;
  myptr[0x36] = rmodseg & 0xff;
  myptr[0x37] = rmodseg >> 8;
 
  /* patch up RMOD's PSP: pointer to previous PSP @ 0x38-0x3B */
  myptr[0x38] = 0;
  myptr[0x39] = 0;
  myptr[0x3A] = rmodseg & 0xff;
  myptr[0x3B] = rmodseg >> 8;
 
  /* copy rmod to its destination (right past the PSP I prepared) */
  myptr = MK_FP(rmodseg, 0x100);
  _fmemcpy(myptr, rmodcore, rmodcore_len);
 
  /* mark rmod memory (MCB) as "self owned" */
  mcb = MK_FP(rmodseg - 1, 0);
  owner = (void far *)(mcb + 1);
  *owner = rmodseg;
  _fmemcpy(mcb + 8, "SVARCOM", 8);
 
  /* mark env memory (MCB) as "owned by rmod" */
  mcb = MK_FP(envseg - 1, 0);
  owner = (void far *)(mcb + 1);
  *owner = rmodseg;
  _fmemcpy(mcb + 8, "SVARENV", 8);
 
  /* if env block is newly allocated, fill it with a few NULLs */
  if (envsize != 0) {
    owner = MK_FP(envseg, 0);
    owner[0] = 0;
    owner[1] = 0;
  }
 
  /* set CTRL+BREAK handler to rmod */
  _asm {
    push ax
    push dx
    push ds
    mov ax, 0x2523
    mov ds, rmodseg
    mov dx, RMOD_OFFSET_BRKHANDLER
    int 0x21
    pop ds
    pop dx
    pop ax
  }
 
  /* mark the input buffer as empty */
  myptr = MK_FP(rmodseg, RMOD_OFFSET_INPUTBUF);
  myptr[0] = 128;  /* max acceptable length */
  myptr[1] = 0;    /* len of currently stored history string */
  myptr[2] = '\r'; /* string terminator */
  myptr[3] = 0xCA; /* signature to detect stack overflow damaging the buffer */
  myptr[4] = 0xFE; /* 2nd byte of the signature */
 
  /* prepare result (rmod props) */
  res = MK_FP(rmodseg, 0x100 + rmodcore_len);
  _fmemset(res, 0, sizeof(*res));  /* zero out */
  res->rmodseg = rmodseg;          /* rmod segment */
  res->origenvseg = origenvseg;    /* original environment segment */
 
  /* write env segment to rmod's PSP */
  owner = MK_FP(rmodseg, RMOD_OFFSET_ENVSEG);
  *owner = envseg;
 
  /* write boot drive to rmod bootdrive field */
  _asm {
    push ax
    push bx
    push dx
    push ds
    mov ax, 0x3305 /* DOS 4.0+ - GET BOOT DRIVE */
    int 0x21 /* boot drive is in DL now (1=A:, 2=B:, etc) */
    add dl, 'A'-1 /* convert to a proper ASCII letter */
    /* set DS to rmodseg */
    mov ax, rmodseg
    mov ds, ax
    /* write boot drive to rmod bootdrive field */
    mov bx, RMOD_OFFSET_BOOTDRIVE
    mov [bx], dl
    pop ds
    pop dx
    pop bx
    pop ax
  }
 
  /* save my original int22h handler and parent in rmod's memory */
  res->origint22 = *((unsigned long *)0x0a); /* original int22h handler seg:off is at 0x0a of my PSP */
  res->origparent = *((unsigned short *)0x16); /* PSP segment of my parent is at 0x16 of my PSP */
 
  /* set the int22 handler in my PSP to rmod so DOS jumps to rmod after I
   * terminate and save the original handler in rmod's memory */
  {
    unsigned short *ptr = (void *)0x0a; /* int22 handler is at 0x0A of the PSP */
    ptr[0] = RMOD_OFFSET_ROUTINE;
    ptr[1] = rmodseg;
  }
 
  /* set my own parent to RMOD (this is not necessary for MS-DOS nor FreeDOS but
   * might be on other DOS implementations) */
  {
    unsigned short *ptr = (void *)0x16;
    *ptr = rmodseg;
  }
 
  return(res);
}
 
 
/* look up my parent: if it's rmod then return a ptr to its props struct,
 * otherwise return NULL
 * I look at PSP[Ch] to locate RMOD (ie. the "terminate address") */
struct rmod_props far *rmod_find(unsigned short rmodcore_len) {
  unsigned short *parent = (void *)0x0C;
  unsigned short far *ptr;
  const unsigned short sig[] = {0x1983, 0x1985, 0x2017, 0x2019};
  unsigned char *cmdtail = (void *)0x80;
  unsigned char i;
  /* is it rmod? */
  ptr = MK_FP(*parent, 0x100);
  for (i = 0; i < 4; i++) if (ptr[i] != sig[i]) return(NULL);
  /* match successfull (rmod is my parent) - but is it really a respawn?
   * command-line tail should contain a single character '\r' */
  if ((cmdtail[0] != 1) || (cmdtail[1] != '\n')) return(NULL);
  cmdtail[0] = 0;
  cmdtail[1] = '\r';
  /* */
  return(MK_FP(*parent, 0x100 + rmodcore_len));
}
 
 
/* update rmod's pointer to comspec */
void rmod_updatecomspecptr(unsigned short rmod_seg, unsigned short env_seg) {
  unsigned short far *comspecptr = MK_FP(rmod_seg, RMOD_OFFSET_COMSPECPTR);
  char far *comspecfp = env_lookup_val(env_seg, "COMSPEC");
  if (comspecfp != NULL) {
    *comspecptr = FP_OFF(comspecfp);
  } else {
    *comspecptr = 0;
  }
}
 
 
/* allocates bytes of far memory, flags it as belonging to rmod
 * the new block can be optionally flagged as 'ident' (if not null) and zero
 * out the newly allocated memory.
 * returns a far ptr to the allocated block, or NULL on error */
void far *rmod_fcalloc(unsigned short bytes, unsigned short rmod_seg, char *ident) {
  unsigned short far *owner;
  unsigned short newseg = 0;
 
  /* ask DOS for a memory block (as high as possible) */
  _asm {
    push bx /* save initial value in BX so I can restore it later */
 
    /* get current allocation strategy and save it on stack */
    mov ax, 0x5800
    int 0x21
    push ax
 
    /* set strategy to 'last fit, try high then low memory' */
    mov ax, 0x5801
    mov bx, 0x0082
    int 0x21
 
    /* ask for a memory block and save the given segment to rmodseg */
    mov ah, 0x48  /* Allocate Memory */
    mov bx, bytes
    add bx, 15    /* convert bytes to paragraphs */
    shr bx, 1     /* bx /= 16 */
    shr bx, 1
    shr bx, 1
    shr bx, 1
    int 0x21
 
    /* error handling */
    jc FAIL
 
    /* save newly allocated segment to newseg */
    mov newseg, ax
 
    FAIL:
    /* restore initial allocation strategy */
    mov ax, 0x5801
    pop bx
    int 0x21
 
    pop bx /* restore BX to its initial value */
  }
 
  if (newseg == 0) return(NULL);
 
  /* mark memory as "owned by rmod" */
  owner = (void far *)(MK_FP(newseg - 1, 1));
  *owner = rmod_seg;
 
  /* set the MCB description to ident, if provided */
  if (ident) {
    char far *mcbdesc = MK_FP(newseg - 1, 8);
    int i;
    _fmemset(mcbdesc, 0, 8);
    for (i = 0; (i < 8) && (ident[i] != 0); i++) { /* field's length is limited to 8 bytes max */
      mcbdesc[i] = ident[i];
    }
  }
 
  /* zero out the memory before handing it out */
  _fmemset(MK_FP(newseg, 0), 0, bytes);
 
  return(MK_FP(newseg, 0));
}
 
 
/* free memory previously allocated by rmod_fcalloc() */
void rmod_ffree(void far *ptr) {
  unsigned short ptrseg;
  unsigned short myseg = 0;
  unsigned short far *owner;
  if (ptr == NULL) return;
  ptrseg = FP_SEG(ptr);
 
  /* get my own segment */
  _asm {
    mov myseg, cs
  }
 
  /* mark memory in MCB as my own, otherwise DOS might refuse to free it */
  owner = MK_FP(ptrseg - 1, 1);
  *owner = myseg;
 
  /* free the memory block */
  _asm {
    push es
    mov ah, 0x49  /* Free Memory Block */
    mov es, ptrseg
    int 0x21
    pop es
  }
}
 
 
/* free the entire linked list of bat ctx nodes (and set its rmod ptr to NULL) */
void rmod_free_bat_llist(struct rmod_props far *rmod) {
  while (rmod->bat != NULL) {
    struct batctx far *victim = rmod->bat;
    rmod->bat = rmod->bat->parent;
    rmod_ffree(victim);
  }
}
 

Rev 1595	Rev 1597
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-2022 Mateusz Viste`	4	`* Copyright (C) 2021-2022 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 <i86.h>`	25	`#include <i86.h>`
26	`#include <string.h>`	26	`#include <string.h>`
27		27
28	`#include "env.h"`	28	`#include "env.h"`
29	`#include "helpers.h"`	29	`#include "helpers.h"`
30		30
31	`#include "rmodinit.h"`	31	`#include "rmodinit.h"`
32		32
33		33
34	`/* returns far pointer to rmod's settings block on success */`	34	`/* returns far pointer to rmod's settings block on success */`
35	`struct rmod_props far rmod_install(unsigned short envsize, unsigned char rmodcore, unsigned short rmodcore_len) {`	35	`struct rmod_props far rmod_install(unsigned short envsize, unsigned char rmodcore, unsigned short rmodcore_len) {`
36	`char far myptr, far mcb;`	36	`char far myptr, far mcb;`
37	`unsigned short far *owner;`	37	`unsigned short far *owner;`
38	`const unsigned short sizeof_rmodandprops_paras = (0x100 + rmodcore_len + sizeof(struct rmod_props) + 15) / 16;`	38	`const unsigned short sizeof_rmodandprops_paras = (0x100 + rmodcore_len + sizeof(struct rmod_props) + 15) / 16;`
39	`unsigned short rmodseg = 0xffff;`	39	`unsigned short rmodseg = 0xffff;`
40	`unsigned short envseg, origenvseg;`	40	`unsigned short envseg, origenvseg;`
41	`struct rmod_props far *res;`	41	`struct rmod_props far *res;`
42		42
43	`/* read my current env segment from PSP and save it */`	43	`/* read my current env segment from PSP and save it */`
44	`envseg = ((unsigned short )0x2c);`	44	`envseg = ((unsigned short )0x2c);`
45	`origenvseg = envseg;`	45	`origenvseg = envseg;`
46		46
47	`/* printf("original (PSP) env buffer at %04X\r\n", envseg); */`	47	`/* printf("original (PSP) env buffer at %04X\r\n", envseg); */`
48		48
49	`/* if envseg is zero, then enforce our own one (MSDOS 5 does not provide a default env) */`	49	`/* if envseg is zero, then enforce our own one (MSDOS 5 does not provide a default env) */`
50	`if ((envseg == 0) && (envsize == 0)) envsize = 256;`	50	`if ((envseg == 0) && (envsize == 0)) envsize = 256;`
51		51
52	`/* if custom envsize requested, convert it to number of paragraphs */`	52	`/* if custom envsize requested, convert it to number of paragraphs */`
53	`if (envsize != 0) {`	53	`if (envsize != 0) {`
54	`envsize += 15;`	54	`envsize += 15;`
55	`envsize /= 16;`	55	`envsize /= 16;`
56	`}`	56	`}`
57		57
58	`_asm {`	58	`_asm {`
59	`push bx`	59	`push bx`
60	`push cx`	60	`push cx`
61	`push dx`	61	`push dx`
62		62
63	`/* link in the UMB memory chain for enabling high-memory allocation (and save initial status on stack) */`	63	`/* link in the UMB memory chain for enabling high-memory allocation (and save initial status on stack) */`
64	`mov ax, 0x5802 /* GET UMB LINK STATE */`	64	`mov ax, 0x5802 /* GET UMB LINK STATE */`
65	`int 0x21`	65	`int 0x21`
66	`xor ah, ah`	66	`xor ah, ah`
67	`push ax /* save link state on stack */`	67	`push ax /* save link state on stack */`
68	`mov ax, 0x5803 /* SET UMB LINK STATE */`	68	`mov ax, 0x5803 /* SET UMB LINK STATE */`
69	`mov bx, 1`	69	`mov bx, 1`
70	`int 0x21`	70	`int 0x21`
71	`/* get current allocation strategy and save it in DX */`	71	`/* get current allocation strategy and save it in DX */`
72	`mov ax, 0x5800`	72	`mov ax, 0x5800`
73	`int 0x21`	73	`int 0x21`
74	`push ax`	74	`push ax`
75	`pop dx`	75	`pop dx`
76	`/* set strategy to 'last fit, try high then low memory' */`	76	`/* set strategy to 'last fit, try high then low memory' */`
77	`mov ax, 0x5801`	77	`mov ax, 0x5801`
78	`mov bx, 0x0082`	78	`mov bx, 0x0082`
79	`int 0x21`	79	`int 0x21`
80	`/* ask for a memory block and save the given segment to rmodseg */`	80	`/* ask for a memory block and save the given segment to rmodseg */`
81	`mov ah, 0x48`	81	`mov ah, 0x48`
82	`mov bx, sizeof_rmodandprops_paras`	82	`mov bx, sizeof_rmodandprops_paras`
83	`int 0x21`	83	`int 0x21`
84	`jc ALLOC_FAIL`	84	`jc ALLOC_FAIL`
85	`mov rmodseg, ax`	85	`mov rmodseg, ax`
86	`/* ask for a memory block for the environment and save it to envseg (only if custom size requested) */`	86	`/* ask for a memory block for the environment and save it to envseg (only if custom size requested) */`
87	`mov bx, envsize`	87	`mov bx, envsize`
88	`test bx, bx`	88	`test bx, bx`
89	`jz ALLOC_FAIL`	89	`jz ALLOC_FAIL`
90	`mov ah, 0x48`	90	`mov ah, 0x48`
91	`int 0x21`	91	`int 0x21`
92	`jc ALLOC_FAIL`	92	`jc ALLOC_FAIL`
93	`mov envseg, ax`	93	`mov envseg, ax`
94		94
95	`ALLOC_FAIL:`	95	`ALLOC_FAIL:`
96	`/* restore initial allocation strategy */`	96	`/* restore initial allocation strategy */`
97	`mov ax, 0x5801`	97	`mov ax, 0x5801`
98	`mov bx, dx`	98	`mov bx, dx`
99	`int 0x21`	99	`int 0x21`
100	`/* restore initial UMB memory link state */`	100	`/* restore initial UMB memory link state */`
101	`mov ax, 0x5803`	101	`mov ax, 0x5803`
102	`pop bx /* pop initial UMB link state from stack */`	102	`pop bx /* pop initial UMB link state from stack */`
103	`int 0x21`	103	`int 0x21`
104		104
105	`pop dx`	105	`pop dx`
106	`pop cx`	106	`pop cx`
107	`pop bx`	107	`pop bx`
108	`}`	108	`}`
109		109
110	`if (rmodseg == 0xffff) {`	110	`if (rmodseg == 0xffff) {`
111	`outputnl("malloc error");`	111	`outputnl("malloc error");`
112	`return(NULL);`	112	`return(NULL);`
113	`}`	113	`}`
114		114
115	`/* generate a new PSP where RMOD is about to land */`	115	`/* generate a new PSP where RMOD is about to land */`
116	`_asm {`	116	`_asm {`
117	`push dx`	117	`push dx`
118	`mov ah, 0x26 /* CREATE NEW PROGRAM SEGMENT PREFIX (DOS 1+) */`	118	`mov ah, 0x26 /* CREATE NEW PROGRAM SEGMENT PREFIX (DOS 1+) */`
119	`mov dx, rmodseg`	119	`mov dx, rmodseg`
120	`int 0x21`	120	`int 0x21`
121	`pop dx`	121	`pop dx`
122	`}`	122	`}`
123		123
124	`myptr = MK_FP(rmodseg, 0);`	124	`myptr = MK_FP(rmodseg, 0);`
125		125
126	`/* patch up RMOD's PSP: Parent's PSP segment @ 0x16-0x17 */`	126	`/* patch up RMOD's PSP: Parent's PSP segment @ 0x16-0x17 */`
127	`myptr[0x16] = rmodseg & 0xff; /* RMOD is his own parent */`	127	`myptr[0x16] = rmodseg & 0xff; /* RMOD is his own parent */`
128	`myptr[0x17] = rmodseg >> 8;`	128	`myptr[0x17] = rmodseg >> 8;`
129		129
130	`/* patch up RMOD's PSP: SS:SP pointer @ 0x2E-0x31 -- I abuse the PSP's`	130	`/* patch up RMOD's PSP: SS:SP pointer @ 0x2E-0x31 -- I abuse the PSP's`
131	`* command line tail as stack, but I do NOT set the stack at the end of the`	131	`* command line tail as stack, but I do NOT set the stack at the end of the`
132	`* tail. E. C. Masloch kindly explained why this would be a bad idea:`	132	`* tail. E. C. Masloch kindly explained why this would be a bad idea:`
133	`*`	133	`*`
134	`* "This is wrong and will potentially overwrite part of your buffers that`	134	`* "This is wrong and will potentially overwrite part of your buffers that`
135	`* start past the PSP. This is because the dword [PSP:2Eh] is not used merely`	135	`* start past the PSP. This is because the dword [PSP:2Eh] is not used merely`
136	`* to set SS:SP but rather to find the stack frame created by the int 21h`	136	`* to set SS:SP but rather to find the stack frame created by the int 21h`
137	`* call. Therefore the int 21h call that terminates the child process will`	137	`* call. Therefore the int 21h call that terminates the child process will`
138	`* then pop a number of registers off starting from the address stored in the`	138	`* then pop a number of registers off starting from the address stored in the`
139	`* PSP." <https://github.com/SvarDOS/bugz/issues/38#issuecomment-1817445740>`	139	`* PSP." <https://github.com/SvarDOS/bugz/issues/38#issuecomment-1817445740>`
140	`*/`	140	`*/`
141	`myptr[0x2e] = 192; /* middle of the command line tail area so I have 64 bytes */`	141	`myptr[0x2e] = 192; /* middle of the command line tail area so I have 64 bytes */`
142	`myptr[0x2f] = 0; /* before and 64 bytes in front of me */`	142	`myptr[0x2f] = 0; /* before and 64 bytes in front of me */`
143	`myptr[0x30] = rmodseg & 0xff;`	143	`myptr[0x30] = rmodseg & 0xff;`
144	`myptr[0x31] = rmodseg >> 8;`	144	`myptr[0x31] = rmodseg >> 8;`
145		145
146	`/* patch up RMOD's PSP: JFT size @ 0x32-0x33 */`	146	`/* patch up RMOD's PSP: JFT size @ 0x32-0x33 */`
147	`myptr[0x32] = 20; /* default JFT size (max that fits without an extra allocation) */`	147	`myptr[0x32] = 20; /* default JFT size (max that fits without an extra allocation) */`
148	`myptr[0x33] = 0;`	148	`myptr[0x33] = 0;`
149		149
150	`/* patch up RMOD's PSP: JFT pointer @ 0x34-0x37 */`	150	`/* patch up RMOD's PSP: JFT pointer @ 0x34-0x37 */`
151	`myptr[0x34] = 0x18; /* the JFT is in the PSP itself */`	151	`myptr[0x34] = 0x18; /* the JFT is in the PSP itself */`
152	`myptr[0x35] = 0;`	152	`myptr[0x35] = 0;`
153	`myptr[0x36] = rmodseg & 0xff;`	153	`myptr[0x36] = rmodseg & 0xff;`
154	`myptr[0x37] = rmodseg >> 8;`	154	`myptr[0x37] = rmodseg >> 8;`
155		155
156	`/* patch up RMOD's PSP: pointer to previous PSP @ 0x38-0x3B */`	156	`/* patch up RMOD's PSP: pointer to previous PSP @ 0x38-0x3B */`
157	`myptr[0x38] = 0;`	157	`myptr[0x38] = 0;`
158	`myptr[0x39] = 0;`	158	`myptr[0x39] = 0;`
159	`myptr[0x3A] = rmodseg & 0xff;`	159	`myptr[0x3A] = rmodseg & 0xff;`
160	`myptr[0x3B] = rmodseg >> 8;`	160	`myptr[0x3B] = rmodseg >> 8;`
161		161
162	`/* copy rmod to its destination (right past the PSP I prepared) */`	162	`/* copy rmod to its destination (right past the PSP I prepared) */`
163	`myptr = MK_FP(rmodseg, 0x100);`	163	`myptr = MK_FP(rmodseg, 0x100);`
164	`_fmemcpy(myptr, rmodcore, rmodcore_len);`	164	`_fmemcpy(myptr, rmodcore, rmodcore_len);`
165		165
166	`/* mark rmod memory (MCB) as "self owned" */`	166	`/* mark rmod memory (MCB) as "self owned" */`
167	`mcb = MK_FP(rmodseg - 1, 0);`	167	`mcb = MK_FP(rmodseg - 1, 0);`
168	`owner = (void far *)(mcb + 1);`	168	`owner = (void far *)(mcb + 1);`
169	`*owner = rmodseg;`	169	`*owner = rmodseg;`
170	`_fmemcpy(mcb + 8, "SVARCOM", 8);`	170	`_fmemcpy(mcb + 8, "SVARCOM", 8);`
171		171
172	`/* mark env memory (MCB) as "owned by rmod" */`	172	`/* mark env memory (MCB) as "owned by rmod" */`
173	`mcb = MK_FP(envseg - 1, 0);`	173	`mcb = MK_FP(envseg - 1, 0);`
174	`owner = (void far *)(mcb + 1);`	174	`owner = (void far *)(mcb + 1);`
175	`*owner = rmodseg;`	175	`*owner = rmodseg;`
176	`_fmemcpy(mcb + 8, "SVARENV", 8);`	176	`_fmemcpy(mcb + 8, "SVARENV", 8);`
177		177
178	`/* if env block is newly allocated, fill it with a few NULLs */`	178	`/* if env block is newly allocated, fill it with a few NULLs */`
179	`if (envsize != 0) {`	179	`if (envsize != 0) {`
180	`owner = MK_FP(envseg, 0);`	180	`owner = MK_FP(envseg, 0);`
181	`owner[0] = 0;`	181	`owner[0] = 0;`
182	`owner[1] = 0;`	182	`owner[1] = 0;`
183	`}`	183	`}`
184		184
185	`/* set CTRL+BREAK handler to rmod */`	185	`/* set CTRL+BREAK handler to rmod */`
186	`_asm {`	186	`_asm {`
187	`push ax`	187	`push ax`
188	`push dx`	188	`push dx`
189	`push ds`	189	`push ds`
190	`mov ax, 0x2523`	190	`mov ax, 0x2523`
191	`mov ds, rmodseg`	191	`mov ds, rmodseg`
192	`mov dx, RMOD_OFFSET_BRKHANDLER`	192	`mov dx, RMOD_OFFSET_BRKHANDLER`
193	`int 0x21`	193	`int 0x21`
194	`pop ds`	194	`pop ds`
195	`pop dx`	195	`pop dx`
196	`pop ax`	196	`pop ax`
197	`}`	197	`}`
198		198
199	`/* mark the input buffer as empty */`	199	`/* mark the input buffer as empty */`
200	`myptr = MK_FP(rmodseg, RMOD_OFFSET_INPUTBUF);`	200	`myptr = MK_FP(rmodseg, RMOD_OFFSET_INPUTBUF);`
201	`myptr[0] = 128; /* max acceptable length */`	201	`myptr[0] = 128; /* max acceptable length */`
202	`myptr[1] = 0; /* len of currently stored history string */`	202	`myptr[1] = 0; /* len of currently stored history string */`
203	`myptr[2] = '\r'; /* string terminator */`	203	`myptr[2] = '\r'; /* string terminator */`
204	`myptr[3] = 0xCA; /* signature to detect stack overflow damaging the buffer */`	204	`myptr[3] = 0xCA; /* signature to detect stack overflow damaging the buffer */`
205	`myptr[4] = 0xFE; /* 2nd byte of the signature */`	205	`myptr[4] = 0xFE; /* 2nd byte of the signature */`
206		206
207	`/* prepare result (rmod props) */`	207	`/* prepare result (rmod props) */`
208	`res = MK_FP(rmodseg, 0x100 + rmodcore_len);`	208	`res = MK_FP(rmodseg, 0x100 + rmodcore_len);`
209	`_fmemset(res, 0, sizeof(res)); / zero out */`	209	`_fmemset(res, 0, sizeof(res)); / zero out */`
210	`res->rmodseg = rmodseg; /* rmod segment */`	210	`res->rmodseg = rmodseg; /* rmod segment */`
211	`res->origenvseg = origenvseg; /* original environment segment */`	211	`res->origenvseg = origenvseg; /* original environment segment */`
212		212
213	`/* write env segment to rmod's PSP */`	213	`/* write env segment to rmod's PSP */`
214	`owner = MK_FP(rmodseg, RMOD_OFFSET_ENVSEG);`	214	`owner = MK_FP(rmodseg, RMOD_OFFSET_ENVSEG);`
215	`*owner = envseg;`	215	`*owner = envseg;`
216		216
217	`/* write boot drive to rmod bootdrive field */`	217	`/* write boot drive to rmod bootdrive field */`
218	`_asm {`	218	`_asm {`
219	`push ax`	219	`push ax`
220	`push bx`	220	`push bx`
221	`push dx`	221	`push dx`
222	`push ds`	222	`push ds`
223	`mov ax, 0x3305 /* DOS 4.0+ - GET BOOT DRIVE */`	223	`mov ax, 0x3305 /* DOS 4.0+ - GET BOOT DRIVE */`
224	`int 0x21 /* boot drive is in DL now (1=A:, 2=B:, etc) */`	224	`int 0x21 /* boot drive is in DL now (1=A:, 2=B:, etc) */`
225	`add dl, 'A'-1 /* convert to a proper ASCII letter */`	225	`add dl, 'A'-1 /* convert to a proper ASCII letter */`
226	`/* set DS to rmodseg */`	226	`/* set DS to rmodseg */`
227	`mov ax, rmodseg`	227	`mov ax, rmodseg`
228	`mov ds, ax`	228	`mov ds, ax`
229	`/* write boot drive to rmod bootdrive field */`	229	`/* write boot drive to rmod bootdrive field */`
230	`mov bx, RMOD_OFFSET_BOOTDRIVE`	230	`mov bx, RMOD_OFFSET_BOOTDRIVE`
231	`mov [bx], dl`	231	`mov [bx], dl`
232	`pop ds`	232	`pop ds`
233	`pop dx`	233	`pop dx`
234	`pop bx`	234	`pop bx`
235	`pop ax`	235	`pop ax`
236	`}`	236	`}`
237		237
238	`/* save my original parent in rmod's memory */`	238	`/* save my original int22h handler and parent in rmod's memory */`
239	`res->origparent = ((unsigned long )0x0a); /* original parent seg:off is at 0x0a of my PSP */`	239	`res->origint22 = ((unsigned long )0x0a); /* original int22h handler seg:off is at 0x0a of my PSP */`
-		240	`res->origparent = ((unsigned short )0x16); /* PSP segment of my parent is at 0x16 of my PSP */`
240		241
241	`/* set the int22 handler in my PSP to rmod so DOS jumps to rmod after I`	242	`/* set the int22 handler in my PSP to rmod so DOS jumps to rmod after I`
242	`* terminate and save the original handler in rmod's memory */`	243	`* terminate and save the original handler in rmod's memory */`
243	`{`	244	`{`
244	`unsigned short ptr = (void )0x0a; /* int22 handler is at 0x0A of the PSP */`	245	`unsigned short ptr = (void )0x0a; /* int22 handler is at 0x0A of the PSP */`
245	`ptr[0] = RMOD_OFFSET_ROUTINE;`	246	`ptr[0] = RMOD_OFFSET_ROUTINE;`
246	`ptr[1] = rmodseg;`	247	`ptr[1] = rmodseg;`
247	`}`	248	`}`
248		249
249	`/* set my own parent to RMOD (this is not necessary for MS-DOS nor FreeDOS but`	250	`/* set my own parent to RMOD (this is not necessary for MS-DOS nor FreeDOS but`
250	`* might be on other DOS implementations) */`	251	`* might be on other DOS implementations) */`
251	`{`	252	`{`
252	`unsigned short ptr = (void )0x16;`	253	`unsigned short ptr = (void )0x16;`
253	`*ptr = rmodseg;`	254	`*ptr = rmodseg;`
254	`}`	255	`}`
255		256
256	`return(res);`	257	`return(res);`
257	`}`	258	`}`
258		259
259		260
260	`/* look up my parent: if it's rmod then return a ptr to its props struct,`	261	`/* look up my parent: if it's rmod then return a ptr to its props struct,`
261	`* otherwise return NULL`	262	`* otherwise return NULL`
262	`* I look at PSP[Ch] to locate RMOD (ie. the "terminate address") */`	263	`* I look at PSP[Ch] to locate RMOD (ie. the "terminate address") */`
263	`struct rmod_props far *rmod_find(unsigned short rmodcore_len) {`	264	`struct rmod_props far *rmod_find(unsigned short rmodcore_len) {`
264	`unsigned short parent = (void )0x0C;`	265	`unsigned short parent = (void )0x0C;`
265	`unsigned short far *ptr;`	266	`unsigned short far *ptr;`
266	`const unsigned short sig[] = {0x1983, 0x1985, 0x2017, 0x2019};`	267	`const unsigned short sig[] = {0x1983, 0x1985, 0x2017, 0x2019};`
267	`unsigned char cmdtail = (void )0x80;`	268	`unsigned char cmdtail = (void )0x80;`
268	`unsigned char i;`	269	`unsigned char i;`
269	`/* is it rmod? */`	270	`/* is it rmod? */`
270	`ptr = MK_FP(*parent, 0x100);`	271	`ptr = MK_FP(*parent, 0x100);`
271	`for (i = 0; i < 4; i++) if (ptr[i] != sig[i]) return(NULL);`	272	`for (i = 0; i < 4; i++) if (ptr[i] != sig[i]) return(NULL);`
272	`/* match successfull (rmod is my parent) - but is it really a respawn?`	273	`/* match successfull (rmod is my parent) - but is it really a respawn?`
273	`* command-line tail should contain a single character '\r' */`	274	`* command-line tail should contain a single character '\r' */`
274	`if ((cmdtail[0] != 1) \|\| (cmdtail[1] != '\n')) return(NULL);`	275	`if ((cmdtail[0] != 1) \|\| (cmdtail[1] != '\n')) return(NULL);`
275	`cmdtail[0] = 0;`	276	`cmdtail[0] = 0;`
276	`cmdtail[1] = '\r';`	277	`cmdtail[1] = '\r';`
277	`/* */`	278	`/* */`
278	`return(MK_FP(*parent, 0x100 + rmodcore_len));`	279	`return(MK_FP(*parent, 0x100 + rmodcore_len));`
279	`}`	280	`}`
280		281
281		282
282	`/* update rmod's pointer to comspec */`	283	`/* update rmod's pointer to comspec */`
283	`void rmod_updatecomspecptr(unsigned short rmod_seg, unsigned short env_seg) {`	284	`void rmod_updatecomspecptr(unsigned short rmod_seg, unsigned short env_seg) {`
284	`unsigned short far *comspecptr = MK_FP(rmod_seg, RMOD_OFFSET_COMSPECPTR);`	285	`unsigned short far *comspecptr = MK_FP(rmod_seg, RMOD_OFFSET_COMSPECPTR);`
285	`char far *comspecfp = env_lookup_val(env_seg, "COMSPEC");`	286	`char far *comspecfp = env_lookup_val(env_seg, "COMSPEC");`
286	`if (comspecfp != NULL) {`	287	`if (comspecfp != NULL) {`
287	`*comspecptr = FP_OFF(comspecfp);`	288	`*comspecptr = FP_OFF(comspecfp);`
288	`} else {`	289	`} else {`
289	`*comspecptr = 0;`	290	`*comspecptr = 0;`
290	`}`	291	`}`
291	`}`	292	`}`
292		293
293		294
294	`/* allocates bytes of far memory, flags it as belonging to rmod`	295	`/* allocates bytes of far memory, flags it as belonging to rmod`
295	`* the new block can be optionally flagged as 'ident' (if not null) and zero`	296	`* the new block can be optionally flagged as 'ident' (if not null) and zero`
296	`* out the newly allocated memory.`	297	`* out the newly allocated memory.`
297	`* returns a far ptr to the allocated block, or NULL on error */`	298	`* returns a far ptr to the allocated block, or NULL on error */`
298	`void far rmod_fcalloc(unsigned short bytes, unsigned short rmod_seg, char ident) {`	299	`void far rmod_fcalloc(unsigned short bytes, unsigned short rmod_seg, char ident) {`
299	`unsigned short far *owner;`	300	`unsigned short far *owner;`
300	`unsigned short newseg = 0;`	301	`unsigned short newseg = 0;`
301		302
302	`/* ask DOS for a memory block (as high as possible) */`	303	`/* ask DOS for a memory block (as high as possible) */`
303	`_asm {`	304	`_asm {`
304	`push bx /* save initial value in BX so I can restore it later */`	305	`push bx /* save initial value in BX so I can restore it later */`
305		306
306	`/* get current allocation strategy and save it on stack */`	307	`/* get current allocation strategy and save it on stack */`
307	`mov ax, 0x5800`	308	`mov ax, 0x5800`
308	`int 0x21`	309	`int 0x21`
309	`push ax`	310	`push ax`
310		311
311	`/* set strategy to 'last fit, try high then low memory' */`	312	`/* set strategy to 'last fit, try high then low memory' */`
312	`mov ax, 0x5801`	313	`mov ax, 0x5801`
313	`mov bx, 0x0082`	314	`mov bx, 0x0082`
314	`int 0x21`	315	`int 0x21`
315		316
316	`/* ask for a memory block and save the given segment to rmodseg */`	317	`/* ask for a memory block and save the given segment to rmodseg */`
317	`mov ah, 0x48 /* Allocate Memory */`	318	`mov ah, 0x48 /* Allocate Memory */`
318	`mov bx, bytes`	319	`mov bx, bytes`
319	`add bx, 15 /* convert bytes to paragraphs */`	320	`add bx, 15 /* convert bytes to paragraphs */`
320	`shr bx, 1 /* bx /= 16 */`	321	`shr bx, 1 /* bx /= 16 */`
321	`shr bx, 1`	322	`shr bx, 1`
322	`shr bx, 1`	323	`shr bx, 1`
323	`shr bx, 1`	324	`shr bx, 1`
324	`int 0x21`	325	`int 0x21`
325		326
326	`/* error handling */`	327	`/* error handling */`
327	`jc FAIL`	328	`jc FAIL`
328		329
329	`/* save newly allocated segment to newseg */`	330	`/* save newly allocated segment to newseg */`
330	`mov newseg, ax`	331	`mov newseg, ax`
331		332
332	`FAIL:`	333	`FAIL:`
333	`/* restore initial allocation strategy */`	334	`/* restore initial allocation strategy */`
334	`mov ax, 0x5801`	335	`mov ax, 0x5801`
335	`pop bx`	336	`pop bx`
336	`int 0x21`	337	`int 0x21`
337		338
338	`pop bx /* restore BX to its initial value */`	339	`pop bx /* restore BX to its initial value */`
339	`}`	340	`}`
340		341
341	`if (newseg == 0) return(NULL);`	342	`if (newseg == 0) return(NULL);`
342		343
343	`/* mark memory as "owned by rmod" */`	344	`/* mark memory as "owned by rmod" */`
344	`owner = (void far *)(MK_FP(newseg - 1, 1));`	345	`owner = (void far *)(MK_FP(newseg - 1, 1));`
345	`*owner = rmod_seg;`	346	`*owner = rmod_seg;`
346		347
347	`/* set the MCB description to ident, if provided */`	348	`/* set the MCB description to ident, if provided */`
348	`if (ident) {`	349	`if (ident) {`
349	`char far *mcbdesc = MK_FP(newseg - 1, 8);`	350	`char far *mcbdesc = MK_FP(newseg - 1, 8);`
350	`int i;`	351	`int i;`
351	`_fmemset(mcbdesc, 0, 8);`	352	`_fmemset(mcbdesc, 0, 8);`
352	`for (i = 0; (i < 8) && (ident[i] != 0); i++) { /* field's length is limited to 8 bytes max */`	353	`for (i = 0; (i < 8) && (ident[i] != 0); i++) { /* field's length is limited to 8 bytes max */`
353	`mcbdesc[i] = ident[i];`	354	`mcbdesc[i] = ident[i];`
354	`}`	355	`}`
355	`}`	356	`}`
356		357
357	`/* zero out the memory before handing it out */`	358	`/* zero out the memory before handing it out */`
358	`_fmemset(MK_FP(newseg, 0), 0, bytes);`	359	`_fmemset(MK_FP(newseg, 0), 0, bytes);`
359		360
360	`return(MK_FP(newseg, 0));`	361	`return(MK_FP(newseg, 0));`
361	`}`	362	`}`
362		363
363		364
364	`/* free memory previously allocated by rmod_fcalloc() */`	365	`/* free memory previously allocated by rmod_fcalloc() */`
365	`void rmod_ffree(void far *ptr) {`	366	`void rmod_ffree(void far *ptr) {`
366	`unsigned short ptrseg;`	367	`unsigned short ptrseg;`
367	`unsigned short myseg = 0;`	368	`unsigned short myseg = 0;`
368	`unsigned short far *owner;`	369	`unsigned short far *owner;`
369	`if (ptr == NULL) return;`	370	`if (ptr == NULL) return;`
370	`ptrseg = FP_SEG(ptr);`	371	`ptrseg = FP_SEG(ptr);`
371		372
372	`/* get my own segment */`	373	`/* get my own segment */`
373	`_asm {`	374	`_asm {`
374	`mov myseg, cs`	375	`mov myseg, cs`
375	`}`	376	`}`
376		377
377	`/* mark memory in MCB as my own, otherwise DOS might refuse to free it */`	378	`/* mark memory in MCB as my own, otherwise DOS might refuse to free it */`
378	`owner = MK_FP(ptrseg - 1, 1);`	379	`owner = MK_FP(ptrseg - 1, 1);`
379	`*owner = myseg;`	380	`*owner = myseg;`
380		381
381	`/* free the memory block */`	382	`/* free the memory block */`
382	`_asm {`	383	`_asm {`
383	`push es`	384	`push es`
384	`mov ah, 0x49 /* Free Memory Block */`	385	`mov ah, 0x49 /* Free Memory Block */`
385	`mov es, ptrseg`	386	`mov es, ptrseg`
386	`int 0x21`	387	`int 0x21`
387	`pop es`	388	`pop es`
388	`}`	389	`}`
389	`}`	390	`}`
390		391
391		392
392	`/* free the entire linked list of bat ctx nodes (and set its rmod ptr to NULL) */`	393	`/* free the entire linked list of bat ctx nodes (and set its rmod ptr to NULL) */`
393	`void rmod_free_bat_llist(struct rmod_props far *rmod) {`	394	`void rmod_free_bat_llist(struct rmod_props far *rmod) {`
394	`while (rmod->bat != NULL) {`	395	`while (rmod->bat != NULL) {`
395	`struct batctx far *victim = rmod->bat;`	396	`struct batctx far *victim = rmod->bat;`
396	`rmod->bat = rmod->bat->parent;`	397	`rmod->bat = rmod->bat->parent;`
397	`rmod_ffree(victim);`	398	`rmod_ffree(victim);`
398	`}`	399	`}`
399	`}`	400	`}`
400		401

Subversion Repositories SvarDOS

(root)/svarcom/trunk/rmodinit.c – Rev 1595 → 1597