Subversion Repositories SvarDOS

Rev

Rev 975 | Rev 987 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
421 mateuszvis 1
/* This file is part of the SvarCOM project and is published under the terms
2
 * of the MIT license.
3
 *
949 mateusz.vi 4
 * Copyright (C) 2021-2022 Mateusz Viste
421 mateuszvis 5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 * copy of this software and associated documentation files (the "Software"),
8
 * to deal in the Software without restriction, including without limitation
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
11
 * Software is furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
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,
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
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
22
 * DEALINGS IN THE SOFTWARE.
23
 */
351 mateuszvis 24
 
25
#include <i86.h>
26
#include <string.h>
27
 
367 mateuszvis 28
#include "env.h"
369 mateuszvis 29
#include "helpers.h"
367 mateuszvis 30
 
351 mateuszvis 31
#include "rmodinit.h"
32
 
33
 
449 mateuszvis 34
/* returns far pointer to rmod's settings block on success */
479 mateuszvis 35
struct rmod_props far *rmod_install(unsigned short envsize, unsigned char *rmodcore, unsigned short rmodcore_len) {
351 mateuszvis 36
  char far *myptr, far *mcb;
37
  unsigned short far *owner;
478 mateuszvis 38
  const unsigned short sizeof_rmodandprops_paras = (0x100 + rmodcore_len + sizeof(struct rmod_props) + 15) / 16;
453 mateuszvis 39
  unsigned short rmodseg = 0xffff;
454 mateuszvis 40
  unsigned short envseg, origenvseg;
465 mateuszvis 41
  struct rmod_props far *res;
351 mateuszvis 42
 
453 mateuszvis 43
  /* read my current env segment from PSP and save it */
454 mateuszvis 44
  envseg = *((unsigned short *)0x2c);
45
  origenvseg = envseg;
351 mateuszvis 46
 
369 mateuszvis 47
  /* printf("original (PSP) env buffer at %04X\r\n", envseg); */
449 mateuszvis 48
 
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;
51
 
351 mateuszvis 52
  /* if custom envsize requested, convert it to number of paragraphs */
53
  if (envsize != 0) {
54
    envsize += 15;
55
    envsize /= 16;
56
  }
57
 
58
  _asm {
59
    /* link in the UMB memory chain for enabling high-memory allocation (and save initial status on stack) */
60
    mov ax, 0x5802  /* GET UMB LINK STATE */
61
    int 0x21
62
    xor ah, ah
63
    push ax         /* save link state on stack */
64
    mov ax, 0x5803  /* SET UMB LINK STATE */
65
    mov bx, 1
66
    int 0x21
67
    /* get current allocation strategy and save it in DX */
68
    mov ax, 0x5800
69
    int 0x21
70
    push ax
71
    pop dx
72
    /* set strategy to 'last fit, try high then low memory' */
73
    mov ax, 0x5801
74
    mov bx, 0x0082
75
    int 0x21
76
    /* ask for a memory block and save the given segment to rmodseg */
77
    mov ah, 0x48
449 mateuszvis 78
    mov bx, sizeof_rmodandprops_paras
351 mateuszvis 79
    int 0x21
80
    jc ALLOC_FAIL
81
    mov rmodseg, ax
82
    /* ask for a memory block for the environment and save it to envseg (only if custom size requested) */
83
    mov bx, envsize
84
    test bx, bx
85
    jz ALLOC_FAIL
86
    mov ah, 0x48
87
    int 0x21
88
    jc ALLOC_FAIL
89
    mov envseg, ax
90
 
91
    ALLOC_FAIL:
92
    /* restore initial allocation strategy */
93
    mov ax, 0x5801
94
    mov bx, dx
95
    int 0x21
96
    /* restore initial UMB memory link state */
97
    mov ax, 0x5803
98
    pop bx       /* pop initial UMB link state from stack */
99
    int 0x21
100
  }
101
 
102
  if (rmodseg == 0xffff) {
369 mateuszvis 103
    outputnl("malloc error");
449 mateuszvis 104
    return(NULL);
351 mateuszvis 105
  }
106
 
459 mateuszvis 107
  /* copy rmod to its destination, prefixed with a copy of my own PSP */
351 mateuszvis 108
  myptr = MK_FP(rmodseg, 0);
459 mateuszvis 109
  {
110
    unsigned short i;
111
    char *mypsp = (void *)0;
112
    for (i = 0; i < 0x100; i++) myptr[i] = mypsp[i];
113
  }
114
  myptr = MK_FP(rmodseg, 0x100);
478 mateuszvis 115
  _fmemcpy(myptr, rmodcore, rmodcore_len);
351 mateuszvis 116
 
117
  /* mark rmod memory as "self owned" */
118
  mcb = MK_FP(rmodseg - 1, 0);
119
  owner = (void far *)(mcb + 1);
120
  *owner = rmodseg;
121
  _fmemcpy(mcb + 8, "SVARCOM", 8);
122
 
448 mateuszvis 123
  /* mark env memory as "owned by rmod" */
359 mateuszvis 124
  mcb = MK_FP(envseg - 1, 0);
125
  owner = (void far *)(mcb + 1);
126
  *owner = rmodseg;
127
  _fmemcpy(mcb + 8, "SVARENV", 8);
351 mateuszvis 128
 
449 mateuszvis 129
  /* if env block is newly allocated, fill it with a few NULLs */
130
  if (envsize != 0) {
131
    owner = MK_FP(envseg, 0);
132
    owner[0] = 0;
133
    owner[1] = 0;
134
  }
135
 
537 mateuszvis 136
  /* set CTRL+BREAK handler to rmod */
137
  _asm {
138
    push ax
139
    push dx
140
    push ds
141
    mov ax, 0x2523
142
    mov ds, rmodseg
143
    mov dx, RMOD_OFFSET_BRKHANDLER
144
    int 0x21
145
    pop ds
146
    pop dx
147
    pop ax
148
  }
149
 
983 mateusz.vi 150
  /* mark the input buffer as empty */
151
  myptr = MK_FP(rmodseg, RMOD_OFFSET_INPUTBUF);
152
  myptr[0] = 128;
153
  myptr[1] = 0;
154
  myptr[2] = '\r';
155
 
449 mateuszvis 156
  /* prepare result (rmod props) */
478 mateuszvis 157
  res = MK_FP(rmodseg, 0x100 + rmodcore_len);
450 mateuszvis 158
  _fmemset(res, 0, sizeof(*res));  /* zero out */
159
  res->rmodseg = rmodseg;          /* rmod segment */
453 mateuszvis 160
  res->origenvseg = origenvseg;    /* original environment segment */
449 mateuszvis 161
 
459 mateuszvis 162
  /* write env segment to rmod's PSP */
351 mateuszvis 163
  owner = MK_FP(rmodseg, RMOD_OFFSET_ENVSEG);
164
  *owner = envseg;
165
 
366 mateuszvis 166
  /* write boot drive to rmod bootdrive field */
167
  _asm {
168
    push ax
169
    push bx
170
    push dx
171
    push ds
172
    mov ax, 0x3305 /* DOS 4.0+ - GET BOOT DRIVE */
173
    int 0x21 /* boot drive is in DL now (1=A:, 2=B:, etc) */
174
    add dl, 'A'-1 /* convert to a proper ASCII letter */
175
    /* set DS to rmodseg */
176
    mov ax, rmodseg
177
    mov ds, ax
178
    /* write boot drive to rmod bootdrive field */
179
    mov bx, RMOD_OFFSET_BOOTDRIVE
180
    mov [bx], dl
181
    pop ds
182
    pop dx
183
    pop bx
184
    pop ax
185
  }
186
 
450 mateuszvis 187
  /* save my original parent in rmod's memory */
188
  res->origparent = *((unsigned long *)0x0a); /* original parent seg:off is at 0x0a of my PSP */
189
 
448 mateuszvis 190
  /* set the int22 handler in my PSP to rmod so DOS jumps to rmod after I
191
   * terminate and save the original handler in rmod's memory */
454 mateuszvis 192
  {
193
    unsigned short *ptr = (void *)0x0a; /* int22 handler is at 0x0A of the PSP */
194
    ptr[0] = RMOD_OFFSET_ROUTINE;
195
    ptr[1] = rmodseg;
351 mateuszvis 196
  }
197
 
449 mateuszvis 198
  return(res);
351 mateuszvis 199
}
200
 
201
 
449 mateuszvis 202
/* look up my parent: if it's rmod then return a ptr to its props struct,
975 mateusz.vi 203
 * otherwise return NULL
983 mateusz.vi 204
 * I look at PSP[Ch] to locate RMOD (ie. the "terminate address") */
479 mateuszvis 205
struct rmod_props far *rmod_find(unsigned short rmodcore_len) {
983 mateusz.vi 206
  unsigned short *parent = (void *)0x0C;
448 mateuszvis 207
  unsigned short far *ptr;
208
  const unsigned short sig[] = {0x1983, 0x1985, 0x2017, 0x2019};
465 mateuszvis 209
  unsigned char *cmdtail = (void *)0x80;
448 mateuszvis 210
  unsigned char i;
211
  /* is it rmod? */
459 mateuszvis 212
  ptr = MK_FP(*parent, 0x100);
449 mateuszvis 213
  for (i = 0; i < 4; i++) if (ptr[i] != sig[i]) return(NULL);
465 mateuszvis 214
  /* match successfull (rmod is my parent) - but is it really a respawn?
215
   * command-line tail should contain a single character '\r' */
216
  if ((cmdtail[0] != 1) || (cmdtail[1] != '\n')) return(NULL);
217
  cmdtail[0] = 0;
218
  cmdtail[1] = '\r';
219
  /* */
478 mateuszvis 220
  return(MK_FP(*parent, 0x100 + rmodcore_len));
351 mateuszvis 221
}
367 mateuszvis 222
 
223
 
224
/* update rmod's pointer to comspec */
225
void rmod_updatecomspecptr(unsigned short rmod_seg, unsigned short env_seg) {
226
  unsigned short far *comspecptr = MK_FP(rmod_seg, RMOD_OFFSET_COMSPECPTR);
439 mateuszvis 227
  char far *comspecfp = env_lookup_val(env_seg, "COMSPEC");
367 mateuszvis 228
  if (comspecfp != NULL) {
439 mateuszvis 229
    *comspecptr = FP_OFF(comspecfp);
367 mateuszvis 230
  } else {
231
    *comspecptr = 0;
232
  }
233
}
949 mateusz.vi 234
 
235
 
236
/* allocates bytes of far memory, flags it as belonging to rmod
957 mateusz.vi 237
 * the new block can be optionally flagged as 'ident' (if not null) and zero
238
 * out the newly allocated memory.
949 mateusz.vi 239
 * returns a far ptr to the allocated block, or NULL on error */
957 mateusz.vi 240
void far *rmod_fcalloc(unsigned short bytes, unsigned short rmod_seg, char *ident) {
949 mateusz.vi 241
  unsigned short far *owner;
242
  unsigned short newseg = 0;
243
 
244
  /* ask DOS for a memory block (as high as possible) */
245
  _asm {
246
    push bx /* save initial value in BX so I can restore it later */
247
 
248
    /* get current allocation strategy and save it on stack */
249
    mov ax, 0x5800
250
    int 0x21
251
    push ax
252
 
253
    /* set strategy to 'last fit, try high then low memory' */
254
    mov ax, 0x5801
255
    mov bx, 0x0082
256
    int 0x21
257
 
258
    /* ask for a memory block and save the given segment to rmodseg */
259
    mov ah, 0x48  /* Allocate Memory */
260
    mov bx, bytes
261
    add bx, 15    /* convert bytes to paragraphs */
262
    shr bx, 1     /* bx /= 16 */
263
    shr bx, 1
264
    shr bx, 1
265
    shr bx, 1
266
    int 0x21
267
 
268
    /* error handling */
269
    jc FAIL
270
 
271
    /* save newly allocated segment to newseg */
272
    mov newseg, ax
273
 
274
    FAIL:
275
    /* restore initial allocation strategy */
276
    mov ax, 0x5801
277
    pop bx
278
    int 0x21
279
 
280
    pop bx /* restore BX to its initial value */
281
  }
282
 
283
  if (newseg == 0) return(NULL);
284
 
285
  /* mark memory as "owned by rmod" */
286
  owner = (void far *)(MK_FP(newseg - 1, 1));
287
  *owner = rmod_seg;
288
 
289
  /* set the MCB description to ident, if provided */
290
  if (ident) {
291
    char far *mcbdesc = MK_FP(newseg - 1, 8);
292
    int i;
293
    _fmemset(mcbdesc, 0, 8);
294
    for (i = 0; (i < 8) && (ident[i] != 0); i++) { /* field's length is limited to 8 bytes max */
295
      mcbdesc[i] = ident[i];
296
    }
297
  }
298
 
957 mateusz.vi 299
  /* zero out the memory before handing it out */
300
  _fmemset(MK_FP(newseg, 0), 0, bytes);
301
 
949 mateusz.vi 302
  return(MK_FP(newseg, 0));
303
}
304
 
305
 
957 mateusz.vi 306
/* free memory previously allocated by rmod_fcalloc() */
949 mateusz.vi 307
void rmod_ffree(void far *ptr) {
308
  unsigned short ptrseg;
309
  unsigned short myseg = 0;
310
  unsigned short far *owner;
311
  if (ptr == NULL) return;
312
  ptrseg = FP_SEG(ptr);
313
 
314
  /* get my own segment */
315
  _asm {
316
    mov myseg, cs
317
  }
318
 
319
  /* mark memory in MCB as my own, otherwise DOS might refuse to free it */
320
  owner = MK_FP(ptrseg - 1, 1);
321
  *owner = myseg;
322
 
323
  /* free the memory block */
324
  _asm {
325
    push es
326
    mov ah, 0x49  /* Free Memory Block */
327
    mov es, ptrseg
328
    int 0x21
329
    pop es
330
  }
331
}
963 mateusz.vi 332
 
333
 
334
/* free the entire linked list of bat ctx nodes (and set its rmod ptr to NULL) */
335
void rmod_free_bat_llist(struct rmod_props far *rmod) {
336
  while (rmod->bat != NULL) {
337
    struct batctx far *victim = rmod->bat;
338
    rmod->bat = rmod->bat->parent;
339
    rmod_ffree(victim);
340
  }
341
}