home *** CD-ROM | disk | FTP | other *** search
/ For Beginners & Professional Hackers / cd.iso / docum / dos-ref.doc / examples / chap2.arj / LDDPMI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-25  |  7.2 KB  |  273 lines
  1. /*
  2. LDDPMI.C -- undocumented DOS call from DPMI
  3.  
  4. sample output:
  5.     in protected mode
  6.     Real mode DOS List Of Lists = 028E:0026
  7.     Protected DOS List Of Lists = 00AD:0026
  8.     LASTDRIVE=E
  9.         
  10. cl -AS lddpmi.c     
  11. */
  12.  
  13. #ifndef M_I86SM
  14. #error Requires Microsoft C small model
  15. #endif
  16.  
  17. #include <stdlib.h>
  18. #include <stdarg.h>
  19. #include <stdio.h>
  20. #include <dos.h>
  21.  
  22. #define ABSADDR(seg, ofs) \
  23.     ((((unsigned long) seg) << 4) + ((ofs) & 0xFFFF))
  24.  
  25. #pragma pack(1)
  26.  
  27. typedef struct {
  28.     unsigned long edi, esi, ebp, reserved, ebx, edx, ecx, eax;
  29.     unsigned flags, es, ds, fs, gs, ip, cs, sp, ss;
  30.     } RMODE_CALL;
  31.     
  32. typedef struct {
  33.     unsigned accessed   : 1;
  34.     unsigned read_write : 1;
  35.     unsigned conf_exp   : 1;
  36.     unsigned code       : 1;
  37.     unsigned xsystem    : 1;
  38.     unsigned dpl        : 2;
  39.     unsigned present    : 1;
  40.     } ACCESS;
  41.     
  42. typedef struct {
  43.     unsigned        limit;
  44.     unsigned        addr_lo;
  45.     unsigned char   addr_hi; 
  46.     ACCESS          access;
  47.     unsigned        reserved;
  48.     } DESCRIPTOR;   
  49.  
  50. typedef enum { FALSE, TRUE } BOOL;
  51.  
  52. BOOL dpmi_rmode_intr(unsigned intno, unsigned flags, 
  53.     unsigned copywords, RMODE_CALL far *rmode_call);
  54.  
  55. void dos_exit(unsigned err)
  56. { 
  57.     _asm mov al, err
  58.     _asm mov ah, 04ch
  59.     _asm int 21h
  60. }
  61.  
  62. void pmode_putchar(int c)
  63. {
  64.     static RMODE_CALL r;
  65.     static RMODE_CALL *pr = (void *) 0;
  66.     if (! pr)
  67.     {
  68.         pr = &r;
  69.         memset(pr, 0, sizeof(RMODE_CALL));
  70.         r.eax = 0x0200;
  71.     }
  72.     r.edx = c;
  73.     dpmi_rmode_intr(0x21, 0, 0, pr);
  74. }
  75.  
  76. void pmode_puts(char *s)
  77. {
  78.     while (*s)
  79.     {
  80.         pmode_putchar(*s);
  81.         s++;
  82.     }
  83.     pmode_putchar(0x0d);
  84.     pmode_putchar(0x0a);
  85. }
  86.  
  87. void cdecl pmode_printf(const char *fmt, ...)
  88. {
  89.     char buf[128], *s=buf;
  90.     va_list marker;
  91.     va_start(marker, fmt);
  92.     vsprintf(buf, fmt, marker); 
  93.     va_end(marker);
  94.     while (*s) 
  95.         pmode_putchar(*s++);
  96. }
  97.  
  98. void fail(char *s)       { puts(s); exit(1); }
  99. void pmode_fail(char *s) { pmode_puts(s); dos_exit(1); }
  100.  
  101. /* Determines if DPMI is present and, if so, switches into
  102.    protected mode */
  103. BOOL dpmi_init(void)
  104. {
  105.     void (far *dpmi)();
  106.     unsigned hostdata_seg, hostdata_para, dpmi_flags;
  107.     _asm {
  108.         mov ax, 1687h           ; test for DPMI presence
  109.         int 2Fh
  110.         and ax, ax
  111.         jnz nodpmi              ; if (AX == 0) DPMI is present
  112.         mov dpmi_flags, bx
  113.         mov hostdata_para, si   ; paras for DPMI host private data
  114.         mov dpmi, di
  115.         mov dpmi+2, es          ; DPMI protected-mode switch entry point
  116.         jmp short gotdpmi
  117.         }
  118. nodpmi:
  119.     return FALSE;
  120. gotdpmi:
  121.     if (_dos_allocmem(hostdata_para, &hostdata_seg) != 0)
  122.         pmode_fail("can't allocate memory");
  123.     
  124.     /* enter protected mode */
  125.     _asm {
  126.         mov ax, hostdata_seg
  127.         mov es, ax
  128.         mov ax, dpmi_flags
  129.         }
  130.     (*dpmi)();
  131.         
  132.     return TRUE;
  133. }
  134.  
  135. /* Performs a real-mode interrupt from protected mode */
  136. BOOL dpmi_rmode_intr(unsigned intno, unsigned flags, 
  137.     unsigned copywords, RMODE_CALL far *rmode_call)
  138. {
  139.     if (flags) intno |= 0x100;
  140.     _asm {
  141.         push di
  142.         push bx
  143.         push cx
  144.         mov ax, 0300h       ; simulate real-mode interrupt
  145.         mov bx, intno       ; interrupt number, flags
  146.         mov cx, copywords;  ; words to copy from pmode to rmode stack
  147.         les di, rmode_call  ; ES:DI = address of rmode call struct
  148.         int 31h             ; call DPMI
  149.         jc error
  150.         mov ax, 1           ; return TRUE
  151.         jmp short done
  152. error:  mov ax, 0           ; return FALSE
  153. done:   pop cx
  154.         pop bx
  155.         pop di
  156.         }
  157. }
  158.  
  159. /* Allocates a single protected-mode LDT selector */
  160. unsigned dpmi_sel(void)
  161. {
  162.     _asm {
  163.         mov ax, 0           ; Allocate LDT Descriptors
  164.         mov cx, 1           ; allocate just one
  165.         int 31h             ; call DPMI
  166.         jc err
  167.         jmp short done      ; AX holds new LDT selector
  168. err:    mov ax, 0           ; failed
  169. done:   }
  170. }
  171.  
  172. BOOL dpmi_set_descriptor(unsigned pmodesel, DESCRIPTOR far *d)
  173. {
  174.     _asm {
  175.         push di
  176.         push bx
  177.         mov ax, 000ch       ; Set Descriptor
  178.         mov bx, pmodesel    ; protected mode selector
  179.         les di, d           ; descriptor
  180.         int 31h             ; call DPMI
  181.         jc error
  182.         mov ax, 1           ; return TRUE
  183.         jmp short done
  184. error:  mov ax, 0           ; return FALSE
  185. done:   pop di
  186.         pop bx
  187.         }
  188. }
  189.  
  190. BOOL dpmi_sel_free(unsigned pmodesel)
  191. {
  192.     _asm {
  193.         mov ax, 0001h       ; Free LDT Descriptor
  194.         mov bx, pmodesel    ; selector to free
  195.         int 31h             ; call DPMI
  196.         jc error
  197.         mov ax, 1           ; return TRUE
  198.         jmp short done
  199. error:  mov ax, 0           ; return FALSE
  200. done:   }
  201. }
  202.  
  203. main(int argc, char *argv[])
  204. {
  205.     DESCRIPTOR d;
  206.     RMODE_CALL r;
  207.     void far *fp;
  208.     char far *doslist = (char far *) 0;
  209.     unsigned long addr;
  210.     unsigned pmodesel;
  211.     unsigned offset, lastdrv_ofs, lastdrv;
  212.     
  213.     /*
  214.         Determine if DPMI present and, if so, switch
  215.         to protected mode
  216.     */  
  217.     if (dpmi_init())
  218.         pmode_puts("now in protected mode");
  219.     else
  220.         fail("DPMI not present");   
  221.  
  222.     /*
  223.         Call INT 21h AH=52h (Get DOS List Of Lists)
  224.     */
  225.     memset(&r, 0, sizeof(RMODE_CALL));
  226.     r.eax = 0x5200;
  227.     if (! dpmi_rmode_intr(0x21, 0, 0, &r))
  228.         pmode_fail("DPMI rmode intr failed");
  229.     FP_SEG(doslist) = r.es;
  230.     FP_OFF(doslist) = r.ebx;
  231.     pmode_printf("Real mode DOS List Of Lists = %Fp\r\n", doslist);
  232.  
  233.     /* doslist now holds a real-mode address: in order to address it
  234.        in protected mode, allocate an LDT descriptor and set its 
  235.        contents; when done, deallocate the LDT descriptor
  236.     */
  237.     if (! (pmodesel = dpmi_sel()))
  238.         pmode_fail("DPMI can't alloc pmode selector");
  239.     d.limit = 0xFFFF;
  240.     addr = ABSADDR(r.es, 0);
  241.     d.addr_lo = addr & 0xFFFF;
  242.     d.addr_hi = addr >> 16;
  243.     d.access.accessed = 0;      /* never been used */
  244.     d.access.read_write = 1;    /* read-write */
  245.     d.access.conf_exp = 0;      /* not a stack */
  246.     d.access.code = 0;          /* data */
  247.     d.access.xsystem = 1;       /* not system descriptor */
  248.     fp = (void far *) main;
  249.     d.access.dpl = FP_SEG(fp) & 3;  /* protection level */
  250.     d.access.present = 1;       /* it's present in memory */
  251.     d.reserved = 0;
  252.     if (! dpmi_set_descriptor(pmodesel, &d))
  253.         pmode_fail("DPMI can't set descriptor");
  254.     
  255.     FP_SEG(doslist) = pmodesel; /* convert to protected-mode address */
  256.     FP_OFF(doslist) = r.ebx;
  257.     pmode_printf("Protected mode DOS List Of Lists = %Fp\r\n", doslist);
  258.  
  259.     /* now have protected-mode selector to DOS List of Lists */
  260.     /* Get LASTDRIVE number, print LASTDRIVE letter */
  261.     lastdrv = doslist[_osmajor==3 && _osminor==0 ? 0x1b : 0x21];
  262.     pmode_printf("LASTDRIVE=%c\r\n", 'A' - 1 + lastdrv);
  263.  
  264.     if (! dpmi_sel_free(pmodesel))
  265.         pmode_fail("DPMI can't free selector");
  266.     
  267.     /* in protected mode, flush output and quit */
  268.     dos_exit(0);
  269.  
  270. dpmifail:
  271.     pmode_fail("DPMI failure");
  272. }
  273.