home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 10 / 10.iso / l / l440 / 2.ddi / CHAP2 / LDDPMI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-14  |  8.4 KB  |  303 lines
  1. /*
  2. LDDPMI.C -- undocumented DOS call from DPMI
  3.  
  4. Revised substantially from the version in UNDOCUMENTED DOS, pp. 74-80
  5.  
  6. This is a DOS program that starts out in real mode, and uses DPMI
  7. to switch into protected mode.  In addition to using DPMI, it also
  8. uses the protected-mode INT 21h services of the Windows 3.0 Enhanced
  9. mode DOS extender (that's why calls to printf, etc. work below,
  10. even after we've switched into protected mode).
  11.  
  12. For information on using DPMI in a Windows program, see the article
  13. "The Programming Challenge of Windows Protected Mode" by Andrew
  14. Schulman, _PC Magazine_, 25 June 1991.
  15.  
  16. Works with Microsoft C 6.0 (or higher) and Borland C++ 2.0 (or higher)
  17. (Some of the _asm convolutions were needed for Borland C++)
  18.  
  19. sample output:
  20.     in protected mode
  21.     Real mode DOS List Of Lists = 028E:0026
  22.     Protected DOS List Of Lists = 00AD:0026
  23.     LASTDRIVE=E
  24.         
  25. Microsoft C 6.0 (or higher): cl -AS lddpmi.c     
  26. Borland C++ 2.0 (or higher): bcc -ms lddpmi.c
  27. */
  28.  
  29. #include <stdlib.h>
  30. #include <stdarg.h>
  31. #include <stdio.h>
  32. #include <assert.h>
  33. #include <dos.h>
  34.  
  35. #ifdef __TURBOC__
  36. #pragma inline
  37. #define _dos_allocmem(x,y)      (allocmem(x, y) != -1)
  38. #endif
  39.  
  40. #define ABSADDR(seg, ofs) \
  41.     ((((unsigned long) seg) << 4) + ((ofs) & 0xFFFF))
  42.  
  43. #pragma pack(1)
  44.  
  45. typedef struct {
  46.     unsigned long edi, esi, ebp, reserved, ebx, edx, ecx, eax;
  47.     unsigned flags, es, ds, fs, gs, ip, cs, sp, ss;
  48.     } RMODE_CALL;
  49.     
  50. typedef struct {
  51.     unsigned char accessed   : 1;
  52.     unsigned char read_write : 1;
  53.     unsigned char conf_exp   : 1;
  54.     unsigned char code       : 1;
  55.     unsigned char xsystem    : 1;
  56.     unsigned char dpl        : 2;
  57.     unsigned char present    : 1;
  58.     } ACCESS;
  59.     
  60. /* structure of a protected-mode descriptor */  
  61. typedef struct {
  62.     unsigned limit, addr_lo;
  63.     unsigned char addr_hi;
  64.     ACCESS access;
  65.     unsigned char reserved, addr_xhi;
  66.     } DESCRIPTOR;   
  67.     
  68. typedef enum { FALSE, TRUE } BOOL;
  69.  
  70. BOOL dpmi_rmode_intr(unsigned intno, unsigned flags, 
  71.     unsigned copywords, RMODE_CALL far *rmode_call);
  72.  
  73. void dos_exit(unsigned char err)
  74. { 
  75.     _asm mov al, err
  76.     _asm mov ah, 04ch
  77.     _asm int 21h
  78. }
  79.  
  80. void fail(char *s)       { puts(s); dos_exit(1); }
  81.  
  82. /* Determines if DPMI is present and, if so, switches into
  83.    protected mode */
  84. BOOL dpmi_init(void)
  85. {
  86.     void (far *dpmi)();
  87.     unsigned hostdata_seg, hostdata_para, dpmi_flags;
  88.     
  89.     _asm {
  90.         mov ax, 1687h           // test for DPMI presence
  91.         int 2Fh
  92.         and ax, ax
  93.         jnz nodpmi              // if (AX == 0) DPMI is present
  94.         mov dpmi_flags, bx
  95.         mov hostdata_para, si   // paras for DPMI host private data
  96.         mov dpmi, di
  97.         mov dpmi+2, es          // DPMI protected-mode switch entry point
  98.         jmp short gotdpmi
  99.         }
  100. nodpmi:
  101.     return FALSE;
  102. gotdpmi:
  103.     if (_dos_allocmem(hostdata_para, &hostdata_seg) != 0)
  104.         fail("can't allocate memory");
  105.     
  106.     /* enter protected mode */
  107.     _asm {
  108.         mov ax, hostdata_seg
  109.         mov es, ax
  110.         mov ax, dpmi_flags
  111.         }
  112.     (*dpmi)();
  113.         
  114.     return TRUE;
  115. }
  116.  
  117. /* Performs a real-mode interrupt from protected mode */
  118. BOOL dpmi_rmode_intr(unsigned intno, unsigned flags, 
  119.     unsigned copywords, RMODE_CALL far *rmode_call)
  120. {
  121.     if (flags) intno |= 0x100;
  122.     _asm {
  123.         push di
  124.         push bx
  125.         push cx
  126.         mov ax, 0300h       // simulate real-mode interrupt
  127.         mov bx, intno       // interrupt number, flags
  128.         mov cx, copywords;  // words to copy from pmode to rmode stack
  129.         les di, rmode_call  // ES:DI = address of rmode call struct
  130.         int 31h             // call DPMI
  131.         jc error
  132.         mov ax, 1           // return TRUE
  133.         jmp short done
  134.         }
  135. error:  
  136.         _asm mov ax, 0           // return FALSE
  137. done:   
  138.         _asm pop cx
  139.         _asm pop bx
  140.         _asm pop di
  141. }
  142.  
  143. /* Allocates a single protected-mode LDT selector */
  144. unsigned dpmi_sel(void)
  145. {
  146.     _asm {
  147.         mov ax, 0           // Allocate LDT Descriptors
  148.         mov cx, 1           // allocate just one
  149.         int 31h             // call DPMI
  150.         jc err
  151.         jmp short done      // AX holds new LDT selector
  152.         }
  153. err:    
  154.         _asm mov ax, 0      // failed
  155. done:;   
  156. }
  157.  
  158. BOOL dpmi_set_descriptor(unsigned pmodesel, DESCRIPTOR far *d)
  159. {
  160.     _asm {
  161.         push di
  162.         push bx
  163.         mov ax, 000ch       // Set Descriptor
  164.         mov bx, pmodesel    // protected mode selector
  165.         les di, d           // descriptor
  166.         int 31h             // call DPMI
  167.         jc error
  168.         mov ax, 1           // return TRUE
  169.         jmp short done
  170.         }
  171. error:  
  172.         _asm mov ax, 0      // return FALSE
  173. done:   
  174.         _asm pop di
  175.         _asm pop bx
  176. }
  177.  
  178. BOOL dpmi_get_descriptor(unsigned pmodesel, DESCRIPTOR far *d)
  179. {
  180.     _asm {
  181.         push di
  182.         mov ax, 000bh       // Get Descriptor
  183.         mov bx, word ptr pmodesel    // protected mode selector
  184.         les di, dword ptr d // descriptor
  185.         int 31h             // call DPMI
  186.         jc error
  187.         mov ax, 1           // return TRUE
  188.         jmp short done
  189.         }
  190. error:  
  191.         _asm xor ax, ax     // return FALSE
  192. done:
  193.         _asm pop di
  194. }
  195.  
  196. BOOL dpmi_sel_free(unsigned pmodesel)
  197. {
  198.     _asm {
  199.         mov ax, 0001h       // Free LDT Descriptor
  200.         mov bx, pmodesel    // selector to free
  201.         int 31h             // call DPMI
  202.         jc error
  203.         mov ax, 1           // return TRUE
  204.         jmp short done
  205.         }
  206. error:  
  207.         _asm mov ax, 0           // return FALSE
  208. done:;
  209. }
  210.  
  211. void far *get_doslist(void)
  212. {
  213.     _asm {
  214.         xor bx, bx
  215.         mov es, bx
  216.         mov ah, 52h
  217.         int 21h
  218.         mov dx, es
  219.         mov ax, bx
  220.         }
  221. }
  222.  
  223. main()
  224. {
  225.     DESCRIPTOR d;
  226.     RMODE_CALL r;
  227.     void far *fp;
  228.     char far *doslist = (char far *) 0;
  229.     unsigned long addr;
  230.     unsigned pmodesel;
  231.     unsigned offset, lastdrv_ofs, lastdrv;
  232.  
  233.     /* program requires small model! */
  234.     assert((sizeof(void*) == 2) && (sizeof(void (*)()) == 2));
  235.     
  236.     assert(sizeof(ACCESS) == 1);
  237.     assert(sizeof(DESCRIPTOR) == 8);
  238.     
  239.     /* Determine if DPMI present and, if so, switch to protected mode */  
  240.     if (dpmi_init())
  241.         puts("now in protected mode");
  242.     else
  243.         fail("DPMI not present");   
  244.     
  245.     /* Call INT 21h AH=52h (Get DOS List Of Lists) */
  246.     memset(&r, 0, sizeof(RMODE_CALL));
  247.     r.eax = 0x5200;
  248.     if (! dpmi_rmode_intr(0x21, 0, 0, &r))
  249.         fail("DPMI rmode intr failed");
  250.     FP_SEG(doslist) = r.es;
  251.     FP_OFF(doslist) = r.ebx;
  252.     printf("Real mode DOS List Of Lists = %Fp\r\n", doslist);
  253.     
  254.     /* doslist now holds a real-mode address: in order to address it
  255.        in protected mode, allocate an LDT descriptor and set its 
  256.        contents; when done, deallocate the LDT descriptor
  257.     */
  258.     if (! (pmodesel = dpmi_sel()))
  259.         fail("DPMI can't alloc pmode selector");
  260.     
  261.     /* set size of segment */
  262.     d.limit = 0xFFFF;
  263.     
  264.     /* set base address of segment */
  265.     addr = ABSADDR(r.es, 0);
  266.     d.addr_lo = addr & 0xFFFF;
  267.     d.addr_hi = addr >> 16;
  268.     d.addr_xhi = 0;             /* IMPORTANT! */
  269.     
  270.     /* set access-rights of segment */
  271.     d.access.accessed = 0;      /* never been used */
  272.     d.access.read_write = 1;    /* read-write */
  273.     d.access.conf_exp = 0;      /* not a stack */
  274.     d.access.code = 0;          /* data */
  275.     d.access.xsystem = 1;       /* not system descriptor */
  276.     fp = (void far *) main;
  277.     d.access.dpl = FP_SEG(fp) & 3;  /* protection level */
  278.     d.access.present = 1;       /* it's present in memory */
  279.     d.reserved = 0;
  280.  
  281.     if (! dpmi_set_descriptor(pmodesel, &d))
  282.         fail("DPMI can't set descriptor");
  283.     
  284.     FP_SEG(doslist) = pmodesel; /* convert to protected-mode address */
  285.     FP_OFF(doslist) = r.ebx;
  286.     printf("Protected mode DOS List Of Lists = %Fp\r\n", doslist);
  287.     
  288.     /* now have protected-mode selector to DOS List of Lists */
  289.     /* Get LASTDRIVE number, print LASTDRIVE letter */
  290.     lastdrv = doslist[_osmajor==3 && _osminor==0 ? 0x1b : 0x21];
  291.     printf("LASTDRIVE=%c\r\n", 'A' - 1 + lastdrv);
  292.     
  293.     if (! dpmi_sel_free(pmodesel))
  294.         fail("DPMI can't free selector");
  295.     
  296.     /* in protected mode, flush output and quit */
  297.     fflush(stdout);
  298.     dos_exit(0);
  299.  
  300. dpmifail:
  301.     fail("DPMI failure");
  302. }
  303.