dlls/winedos/devices.c

   1 /*
   2  * DOS devices
   3  *
   4  * Copyright 1999 Ove Kåven
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "wine/winbase16.h"
  10 #include "msdos.h"
  11 #include "miscemu.h"
  12 #include "dosexe.h"
  13 #include "debugtools.h"
  14
  15 #include "pshpack1.h"
  16
  17 typedef struct {
  18   BYTE ljmp1;
  19   RMCBPROC strategy;
  20   BYTE ljmp2;
  21   RMCBPROC interrupt;
  22 } WINEDEV_THUNK;
  23
  24 typedef struct {
  25   BYTE size; /* length of header + data */
  26   BYTE unit; /* unit (block devices only) */
  27   BYTE command;
  28   WORD status;
  29   BYTE reserved[8];
  30 } REQUEST_HEADER;
  31
  32 typedef struct {
  33   REQUEST_HEADER hdr;
  34   BYTE media; /* media descriptor from BPB */
  35   SEGPTR buffer;
  36   WORD count; /* byte/sector count */
  37   WORD sector; /* starting sector (block devices) */
  38   DWORD volume; /* volume ID (block devices) */
  39 } REQ_IO;
  40
  41 typedef struct {
  42   REQUEST_HEADER hdr;
  43   BYTE data;
  44 } REQ_SAFEINPUT;
  45
  46 #include "poppack.h"
  47
  48 #define CON_BUFFER 128
  49
  50 enum strategy { SYSTEM_STRATEGY_NUL, SYSTEM_STRATEGY_CON, NB_SYSTEM_STRATEGIES };
  51
  52 static void *strategy_data[NB_SYSTEM_STRATEGIES];
  53
  54 #define NONEXT ((DWORD)-1)
  55
  56 #define ATTR_STDIN     0x0001
  57 #define ATTR_STDOUT    0x0002
  58 #define ATTR_NUL       0x0004
  59 #define ATTR_CLOCK     0x0008
  60 #define ATTR_FASTCON   0x0010
  61 #define ATTR_RAW       0x0020
  62 #define ATTR_NOTEOF    0x0040
  63 #define ATTR_DEVICE    0x0080
  64 #define ATTR_REMOVABLE 0x0800
  65 #define ATTR_NONIBM    0x2000 /* block devices */
  66 #define ATTR_UNTILBUSY 0x2000 /* char devices */
  67 #define ATTR_IOCTL     0x4000
  68 #define ATTR_CHAR      0x8000
  69
  70 #define CMD_INIT       0
  71 #define CMD_MEDIACHECK 1 /* block devices */
  72 #define CMD_BUILDBPB   2 /* block devices */
  73 #define CMD_INIOCTL    3
  74 #define CMD_INPUT      4 /* read data */
  75 #define CMD_SAFEINPUT  5 /* "non-destructive input no wait", char devices */
  76 #define CMD_INSTATUS   6 /* char devices */
  77 #define CMD_INFLUSH    7 /* char devices */
  78 #define CMD_OUTPUT     8 /* write data */
  79 #define CMD_SAFEOUTPUT 9 /* write data with verify */
  80 #define CMD_OUTSTATUS 10 /* char devices */
  81 #define CMD_OUTFLUSH  11 /* char devices */
  82 #define CMD_OUTIOCTL  12
  83 #define CMD_DEVOPEN   13
  84 #define CMD_DEVCLOSE  14
  85 #define CMD_REMOVABLE 15 /* block devices */
  86 #define CMD_UNTILBUSY 16 /* output until busy */
  87
  88 #define STAT_MASK  0x00FF
  89 #define STAT_DONE  0x0100
  90 #define STAT_BUSY  0x0200
  91 #define STAT_ERROR 0x8000
  92
  93 #define LJMP 0xea
  94
  95
  96 /* prototypes */
  97 static void WINAPI nul_strategy(CONTEXT86*ctx);
  98 static void WINAPI nul_interrupt(CONTEXT86*ctx);
  99 static void WINAPI con_strategy(CONTEXT86*ctx);
 100 static void WINAPI con_interrupt(CONTEXT86*ctx);
 101
 102 /* devices */
 103 typedef struct
 104 {
 105     char name[8];
 106     WORD attr;
 107     RMCBPROC strategy;
 108     RMCBPROC interrupt;
 109 } WINEDEV;
 110
 111 static WINEDEV devs[] =
 112 {
 113   { "NUL     ",
 114     ATTR_CHAR|ATTR_NUL|ATTR_DEVICE,
 115     nul_strategy, nul_interrupt },
 116
 117   { "CON     ",
 118     ATTR_CHAR|ATTR_STDIN|ATTR_STDOUT|ATTR_FASTCON|ATTR_NOTEOF|ATTR_DEVICE,
 119     con_strategy, con_interrupt }
 120 };
 121
 122 #define NR_DEVS (sizeof(devs)/sizeof(WINEDEV))
 123
 124 /* DOS data segment */
 125 typedef struct
 126 {
 127     DOS_LISTOFLISTS    lol;
 128     DOS_DEVICE_HEADER  dev[NR_DEVS-1];
 129     WINEDEV_THUNK      thunk[NR_DEVS];
 130     REQ_IO             req;
 131     BYTE               buffer[CON_BUFFER];
 132
 133 } DOS_DATASEG;
 134
 135 #define DOS_DATASEG_OFF(xxx) FIELD_OFFSET(DOS_DATASEG, xxx)
 136
 137 struct _DOS_LISTOFLISTS * DOSMEM_LOL()
 138 {
 139     return (struct _DOS_LISTOFLISTS *)DOSMEM_MapRealToLinear
 140       (MAKESEGPTR(HIWORD(DOS_LOLSeg),0));
 141 }
 142
 143
 144 /* the device implementations */
 145 static void do_lret(CONTEXT86*ctx)
 146 {
 147   WORD *stack = CTX_SEG_OFF_TO_LIN(ctx, ctx->SegSs, ctx->Esp);
 148
 149   ctx->Eip   = *(stack++);
 150   ctx->SegCs = *(stack++);
 151   ctx->Esp  += 2*sizeof(WORD);
 152 }
 153
 154 static void do_strategy(CONTEXT86*ctx, int id, int extra)
 155 {
 156   REQUEST_HEADER *hdr = CTX_SEG_OFF_TO_LIN(ctx, ctx->SegEs, ctx->Ebx);
 157   void **hdr_ptr = strategy_data[id];
 158
 159   if (!hdr_ptr) {
 160     hdr_ptr = calloc(1,sizeof(void *)+extra);
 161     strategy_data[id] = hdr_ptr;
 162   }
 163   *hdr_ptr = hdr;
 164   do_lret(ctx);
 165 }
 166
 167 static REQUEST_HEADER * get_hdr(int id, void**extra)
 168 {
 169   void **hdr_ptr = strategy_data[id];
 170   if (extra)
 171     *extra = hdr_ptr ? (void*)(hdr_ptr+1) : (void *)NULL;
 172   return hdr_ptr ? *hdr_ptr : (void *)NULL;
 173 }
 174
 175 static void WINAPI nul_strategy(CONTEXT86*ctx)
 176 {
 177   do_strategy(ctx, SYSTEM_STRATEGY_NUL, 0);
 178 }
 179
 180 static void WINAPI nul_interrupt(CONTEXT86*ctx)
 181 {
 182   REQUEST_HEADER *hdr = get_hdr(SYSTEM_STRATEGY_NUL, NULL);
 183   /* eat everything and recycle nothing */
 184   switch (hdr->command) {
 185   case CMD_INPUT:
 186     ((REQ_IO*)hdr)->count = 0;
 187     hdr->status = STAT_DONE;
 188     break;
 189   case CMD_SAFEINPUT:
 190     hdr->status = STAT_DONE|STAT_BUSY;
 191     break;
 192   default:
 193     hdr->status = STAT_DONE;
 194   }
 195   do_lret(ctx);
 196 }
 197
 198 static void WINAPI con_strategy(CONTEXT86*ctx)
 199 {
 200   do_strategy(ctx, SYSTEM_STRATEGY_CON, sizeof(int));
 201 }
 202
 203 static void WINAPI con_interrupt(CONTEXT86*ctx)
 204 {
 205   int *scan;
 206   REQUEST_HEADER *hdr = get_hdr(SYSTEM_STRATEGY_CON,(void **)&scan);
 207   BIOSDATA *bios = DOSMEM_BiosData();
 208   WORD CurOfs = bios->NextKbdCharPtr;
 209   DOS_LISTOFLISTS *lol = DOSMEM_LOL();
 210   DOS_DATASEG *dataseg = (DOS_DATASEG *)lol;
 211   BYTE *linebuffer = dataseg->buffer;
 212   BYTE *curbuffer = (lol->offs_unread_CON) ?
 213     (((BYTE*)dataseg) + lol->offs_unread_CON) : (BYTE*)NULL;
 214   DOS_DEVICE_HEADER *con = dataseg->dev;
 215
 216   switch (hdr->command) {
 217   case CMD_INPUT:
 218     {
 219       REQ_IO *io = (REQ_IO *)hdr;
 220       WORD count = io->count, len = 0;
 221       BYTE *buffer = CTX_SEG_OFF_TO_LIN(ctx,
 222                                         SELECTOROF(io->buffer),
 223                                         (DWORD)OFFSETOF(io->buffer));
 224
 225       hdr->status = STAT_BUSY;
 226       /* first, check whether we already have data in line buffer */
 227       if (curbuffer) {
 228         /* yep, copy as much as we can */
 229         BYTE data = 0;
 230         while ((len<count) && (data != '\r')) {
 231           data = *curbuffer++;
 232           buffer[len++] = data;
 233         }
 234         if (data == '\r') {
 235           /* line buffer emptied */
 236           lol->offs_unread_CON = 0;
 237           curbuffer = NULL;
 238           /* if we're not in raw mode, call it a day*/
 239           if (!(con->attr & ATTR_RAW)) {
 240             hdr->status = STAT_DONE;
 241             io->count = len;
 242             break;
 243           }
 244         } else {
 245           /* still some data left */
 246           lol->offs_unread_CON = curbuffer - (BYTE*)lol;
 247           /* but buffer was filled, we're done */
 248           hdr->status = STAT_DONE;
 249           io->count = len;
 250           break;
 251         }
 252       }
 253
 254       /* if we're in raw mode, we just need to fill the buffer */
 255       if (con->attr & ATTR_RAW) {
 256         while (len<count) {
 257           WORD data;
 258
 259           /* do we have a waiting scancode? */
 260           if (*scan) {
 261             /* yes, store scancode in buffer */
 262             buffer[len++] = *scan;
 263             *scan = 0;
 264             if (len==count) break;
 265           }
 266
 267           /* check for new keyboard input */
 268           while (CurOfs == bios->FirstKbdCharPtr) {
 269             /* no input available yet, so wait... */
 270             DOSVM_Wait( -1, 0 );
 271           }
 272           /* read from keyboard queue (call int16?) */
 273           data = ((WORD*)bios)[CurOfs];
 274           CurOfs += 2;
 275           if (CurOfs >= bios->KbdBufferEnd) CurOfs = bios->KbdBufferStart;
 276           bios->NextKbdCharPtr = CurOfs;
 277           /* if it's an extended key, save scancode */
 278           if (LOBYTE(data) == 0) *scan = HIBYTE(data);
 279           /* store ASCII char in buffer */
 280           buffer[len++] = LOBYTE(data);
 281         }
 282       } else {
 283         /* we're not in raw mode, so we need to do line input... */
 284         while (TRUE) {
 285           WORD data;
 286           /* check for new keyboard input */
 287           while (CurOfs == bios->FirstKbdCharPtr) {
 288             /* no input available yet, so wait... */
 289             DOSVM_Wait( -1, 0 );
 290           }
 291           /* read from keyboard queue (call int16?) */
 292           data = ((WORD*)bios)[CurOfs];
 293           CurOfs += 2;
 294           if (CurOfs >= bios->KbdBufferEnd) CurOfs = bios->KbdBufferStart;
 295           bios->NextKbdCharPtr = CurOfs;
 296
 297           if (LOBYTE(data) == '\r') {
 298             /* it's the return key, we're done */
 299             linebuffer[len++] = LOBYTE(data);
 300             break;
 301           }
 302           else if (LOBYTE(data) >= ' ') {
 303             /* a character */
 304             if ((len+1)<CON_BUFFER) {
 305               linebuffer[len] = LOBYTE(data);
 306               WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), &linebuffer[len++], 1, NULL, NULL);
 307             }
 308             /* else beep, but I don't like noise */
 309           }
 310           else switch (LOBYTE(data)) {
 311           case '\b':
 312             if (len>0) {
 313               len--;
 314               WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "\b \b", 3, NULL, NULL);
 315             }
 316             break;
 317           }
 318         }
 319         if (len > count) {
 320           /* save rest of line for later */
 321           lol->offs_unread_CON = linebuffer - (BYTE*)lol + count;
 322           len = count;
 323         }
 324         memcpy(buffer, linebuffer, len);
 325       }
 326       hdr->status = STAT_DONE;
 327       io->count = len;
 328     }
 329     break;
 330   case CMD_SAFEINPUT:
 331     if (curbuffer) {
 332       /* some line input waiting */
 333       hdr->status = STAT_DONE;
 334       ((REQ_SAFEINPUT*)hdr)->data = *curbuffer;
 335     }
 336     else if (con->attr & ATTR_RAW) {
 337       if (CurOfs == bios->FirstKbdCharPtr) {
 338         /* no input */
 339         hdr->status = STAT_DONE|STAT_BUSY;
 340       } else {
 341         /* some keyboard input waiting */
 342         hdr->status = STAT_DONE;
 343         ((REQ_SAFEINPUT*)hdr)->data = ((BYTE*)bios)[CurOfs];
 344       }
 345     } else {
 346       /* no line input */
 347       hdr->status = STAT_DONE|STAT_BUSY;
 348     }
 349     break;
 350   case CMD_INSTATUS:
 351     if (curbuffer) {
 352       /* we have data */
 353       hdr->status = STAT_DONE;
 354     }
 355     else if (con->attr & ATTR_RAW) {
 356       if (CurOfs == bios->FirstKbdCharPtr) {
 357         /* no input */
 358         hdr->status = STAT_DONE|STAT_BUSY;
 359       } else {
 360         /* some keyboard input waiting */
 361         hdr->status = STAT_DONE;
 362       }
 363     } else {
 364       /* no line input */
 365       hdr->status = STAT_DONE|STAT_BUSY;
 366     }
 367
 368     break;
 369   case CMD_INFLUSH:
 370     /* flush line and keyboard queue */
 371     lol->offs_unread_CON = 0;
 372     bios->NextKbdCharPtr = bios->FirstKbdCharPtr;
 373     break;
 374   case CMD_OUTPUT:
 375   case CMD_SAFEOUTPUT:
 376     {
 377       REQ_IO *io = (REQ_IO *)hdr;
 378       BYTE *buffer = CTX_SEG_OFF_TO_LIN(ctx,
 379                                         SELECTOROF(io->buffer),
 380                                         (DWORD)OFFSETOF(io->buffer));
 381       DWORD result = 0;
 382       WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, io->count, &result, NULL);
 383       io->count = result;
 384       hdr->status = STAT_DONE;
 385     }
 386     break;
 387   default:
 388     hdr->status = STAT_DONE;
 389   }
 390   do_lret(ctx);
 391 }
 392
 393 static void InitListOfLists(DOS_LISTOFLISTS *DOS_LOL)
 394 {
 395 /*
 396 Output of DOS 6.22:
 397
 398 0133:0020                    6A 13-33 01 CC 00 33 01 59 00         j.3...3.Y.
 399 0133:0030  70 00 00 00 72 02 00 02-6D 00 33 01 00 00 2E 05   p...r...m.3.....
 400 0133:0040  00 00 FC 04 00 00 03 08-92 21 11 E0 04 80 C6 0D   .........!......
 401 0133:0050  CC 0D 4E 55 4C 20 20 20-20 20 00 00 00 00 00 00   ..NUL     ......
 402 0133:0060  00 4B BA C1 06 14 00 00-00 03 01 00 04 70 CE FF   .K...........p..
 403 0133:0070  FF 00 00 00 00 00 00 00-00 01 00 00 0D 05 00 00   ................
 404 0133:0080  00 FF FF 00 00 00 00 FE-00 00 F8 03 FF 9F 70 02   ..............p.
 405 0133:0090  D0 44 C8 FD D4 44 C8 FD-D4 44 C8 FD D0 44 C8 FD   .D...D...D...D..
 406 0133:00A0  D0 44 C8 FD D0 44                                 .D...D
 407 */
 408   DOS_LOL->CX_Int21_5e01                = 0x0;
 409   DOS_LOL->LRU_count_FCB_cache  = 0x0;
 410   DOS_LOL->LRU_count_FCB_open           = 0x0;
 411   DOS_LOL->OEM_func_handler             = -1; /* not available */
 412   DOS_LOL->INT21_offset         = 0x0;
 413   DOS_LOL->sharing_retry_count  = 3;
 414   DOS_LOL->sharing_retry_delay  = 1;
 415   DOS_LOL->ptr_disk_buf         = 0x0;
 416   DOS_LOL->offs_unread_CON              = 0x0;
 417   DOS_LOL->seg_first_MCB                = 0x0;
 418   DOS_LOL->ptr_first_DPB                = 0x0;
 419   DOS_LOL->ptr_first_SysFileTable       = 0x0;
 420   DOS_LOL->ptr_clock_dev_hdr            = 0x0;
 421   DOS_LOL->ptr_CON_dev_hdr              = 0x0;
 422   DOS_LOL->max_byte_per_sec             = 512;
 423   DOS_LOL->ptr_disk_buf_info            = 0x0;
 424   DOS_LOL->ptr_array_CDS                = 0x0;
 425   DOS_LOL->ptr_sys_FCB          = 0x0;
 426   DOS_LOL->nr_protect_FCB               = 0x0;
 427   DOS_LOL->nr_block_dev         = 0x0;
 428   DOS_LOL->nr_avail_drive_letters       = 26; /* A - Z */
 429   DOS_LOL->nr_drives_JOINed             = 0x0;
 430   DOS_LOL->ptr_spec_prg_names           = 0x0;
 431   DOS_LOL->ptr_SETVER_prg_list  = 0x0; /* no SETVER list */
 432   DOS_LOL->DOS_HIGH_A20_func_offs       = 0x0;
 433   DOS_LOL->PSP_last_exec                = 0x0;
 434   DOS_LOL->BUFFERS_val          = 99; /* maximum: 99 */
 435   DOS_LOL->BUFFERS_nr_lookahead = 8; /* maximum: 8 */
 436   DOS_LOL->boot_drive                   = 3; /* C: */
 437   DOS_LOL->flag_DWORD_moves             = 0x01; /* i386+ */
 438   DOS_LOL->size_extended_mem            = 0xf000; /* very high value */
 439 }
 440
 441 void DOSDEV_InstallDOSDevices(void)
 442 {
 443   DOS_DATASEG *dataseg;
 444   UINT16 seg;
 445   unsigned int n;
 446
 447   /* allocate DOS data segment or something */
 448   DOS_LOLSeg = GlobalDOSAlloc16(sizeof(DOS_DATASEG));
 449   seg = HIWORD(DOS_LOLSeg);
 450   dataseg = MapSL( MAKESEGPTR(LOWORD(DOS_LOLSeg), 0) );
 451
 452   /* initialize the magnificent List Of Lists */
 453   InitListOfLists(&dataseg->lol);
 454
 455   /* Set up first device (NUL) */
 456   dataseg->lol.NUL_dev.next_dev  = MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[0]));
 457   dataseg->lol.NUL_dev.attr      = devs[0].attr;
 458   dataseg->lol.NUL_dev.strategy  = DOS_DATASEG_OFF(thunk[0].ljmp1);
 459   dataseg->lol.NUL_dev.interrupt = DOS_DATASEG_OFF(thunk[0].ljmp2);
 460   memcpy(dataseg->lol.NUL_dev.name, devs[0].name, 8);
 461
 462   /* Set up the remaining devices */
 463   for (n = 1; n < NR_DEVS; n++)
 464   {
 465     dataseg->dev[n-1].next_dev  = (n+1) == NR_DEVS ? NONEXT :
 466                                   MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[n]));
 467     dataseg->dev[n-1].attr      = devs[n].attr;
 468     dataseg->dev[n-1].strategy  = DOS_DATASEG_OFF(thunk[n].ljmp1);
 469     dataseg->dev[n-1].interrupt = DOS_DATASEG_OFF(thunk[n].ljmp2);
 470     memcpy(dataseg->dev[n-1].name, devs[n].name, 8);
 471   }
 472
 473   /* Set up thunks */
 474   for (n = 0; n < NR_DEVS; n++)
 475   {
 476     dataseg->thunk[n].ljmp1     = LJMP;
 477     dataseg->thunk[n].strategy  = (RMCBPROC)DPMI_AllocInternalRMCB(devs[n].strategy);
 478     dataseg->thunk[n].ljmp2     = LJMP;
 479     dataseg->thunk[n].interrupt = (RMCBPROC)DPMI_AllocInternalRMCB(devs[n].interrupt);
 480   }
 481
 482   /* CON is device 1 */
 483   dataseg->lol.ptr_CON_dev_hdr = MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[0]));
 484 }
 485
 486 DWORD DOSDEV_Console(void)
 487 {
 488   return DOSMEM_LOL()->ptr_CON_dev_hdr;
 489 }
 490
 491 DWORD DOSDEV_FindCharDevice(char*name)
 492 {
 493   SEGPTR cur_ptr = MAKESEGPTR(HIWORD(DOS_LOLSeg), FIELD_OFFSET(DOS_LISTOFLISTS,NUL_dev));
 494   DOS_DEVICE_HEADER *cur = DOSMEM_MapRealToLinear(cur_ptr);
 495   char dname[8];
 496   int cnt;
 497
 498   /* get first 8 characters */
 499   strncpy(dname,name,8);
 500   /* if less than 8 characters, pad with spaces */
 501   for (cnt=0; cnt<8; cnt++)
 502     if (!dname[cnt]) dname[cnt]=' ';
 503
 504   /* search for char devices with the right name */
 505   while (cur &&
 506          ((!(cur->attr & ATTR_CHAR)) ||
 507           memcmp(cur->name,dname,8))) {
 508     cur_ptr = cur->next_dev;
 509     if (cur_ptr == NONEXT) cur=NULL;
 510     else cur = DOSMEM_MapRealToLinear(cur_ptr);
 511   }
 512   return cur_ptr;
 513 }
 514
 515 static void DOSDEV_DoReq(void*req, DWORD dev)
 516 {
 517   REQUEST_HEADER *hdr = (REQUEST_HEADER *)req;
 518   DOS_DEVICE_HEADER *dhdr;
 519   CONTEXT86 ctx;
 520   char *phdr;
 521
 522   dhdr = DOSMEM_MapRealToLinear(dev);
 523   phdr = ((char*)DOSMEM_LOL()) + DOS_DATASEG_OFF(req);
 524
 525   /* copy request to request scratch area */
 526   memcpy(phdr, req, hdr->size);
 527
 528   /* prepare to call device driver */
 529   memset(&ctx, 0, sizeof(ctx));
 530
 531   /* ES:BX points to request for strategy routine */
 532   ctx.SegEs = HIWORD(DOS_LOLSeg);
 533   ctx.Ebx   = DOS_DATASEG_OFF(req);
 534
 535   /* call strategy routine */
 536   ctx.SegCs = SELECTOROF(dev);
 537   ctx.Eip   = dhdr->strategy;
 538   DPMI_CallRMProc(&ctx, 0, 0, 0);
 539
 540   /* call interrupt routine */
 541   ctx.SegCs = SELECTOROF(dev);
 542   ctx.Eip   = dhdr->interrupt;
 543   DPMI_CallRMProc(&ctx, 0, 0, 0);
 544
 545   /* completed, copy request back */
 546   memcpy(req, phdr, hdr->size);
 547
 548   if (hdr->status & STAT_ERROR) {
 549     switch (hdr->status & STAT_MASK) {
 550     case 0x0F: /* invalid disk change */
 551       /* this error seems to fit the bill */
 552       SetLastError(ER_NotSameDevice);
 553       break;
 554     default:
 555       SetLastError((hdr->status & STAT_MASK) + 0x13);
 556       break;
 557     }
 558   }
 559 }
 560
 561 static int DOSDEV_IO(unsigned cmd, DWORD dev, DWORD buf, int buflen)
 562 {
 563   REQ_IO req;
 564
 565   req.hdr.size=sizeof(req);
 566   req.hdr.unit=0; /* not dealing with block devices yet */
 567   req.hdr.command=cmd;
 568   req.hdr.status=STAT_BUSY;
 569   req.media=0; /* not dealing with block devices yet */
 570   req.buffer=buf;
 571   req.count=buflen;
 572   req.sector=0; /* block devices */
 573   req.volume=0; /* block devices */
 574
 575   DOSDEV_DoReq(&req, dev);
 576
 577   return req.count;
 578 }
 579
 580 int DOSDEV_Peek(DWORD dev, BYTE*data)
 581 {
 582   REQ_SAFEINPUT req;
 583
 584   req.hdr.size=sizeof(req);
 585   req.hdr.unit=0; /* not dealing with block devices yet */
 586   req.hdr.command=CMD_SAFEINPUT;
 587   req.hdr.status=STAT_BUSY;
 588   req.data=0;
 589
 590   DOSDEV_DoReq(&req, dev);
 591
 592   if (req.hdr.status & STAT_BUSY) return 0;
 593
 594   *data = req.data;
 595   return 1;
 596 }
 597
 598 int DOSDEV_Read(DWORD dev, DWORD buf, int buflen)
 599 {
 600   return DOSDEV_IO(CMD_INPUT, dev, buf, buflen);
 601 }
 602
 603 int DOSDEV_Write(DWORD dev, DWORD buf, int buflen, int verify)
 604 {
 605   return DOSDEV_IO(verify?CMD_SAFEOUTPUT:CMD_OUTPUT, dev, buf, buflen);
 606 }
 607
 608 int DOSDEV_IoctlRead(DWORD dev, DWORD buf, int buflen)
 609 {
 610   return DOSDEV_IO(CMD_INIOCTL, dev, buf, buflen);
 611 }
 612
 613 int DOSDEV_IoctlWrite(DWORD dev, DWORD buf, int buflen)
 614 {
 615   return DOSDEV_IO(CMD_OUTIOCTL, dev, buf, buflen);
 616 }