home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 5 Developer's Kit / vb5 dev kit.iso / dev / call32 / source / call32.c next >
Encoding:
C/C++ Source or Header  |  1996-09-10  |  13.8 KB  |  394 lines
  1. //----------------------------------------------------------
  2. // CALL32.C
  3. //
  4. // This creates a DLL for 16-bit Visual Basic programs to
  5. // call 32-bit DLLs on Windows NT 3.1.  It uses the 
  6. // Generic Thunks feature of the WOW subsystem on Windows
  7. // NT and 95 to load and call 32 bit DLLs.  This file should
  8. // be compiled into a 16-bit DLL.
  9. //
  10. // Written by Peter Golde
  11. //     Version 1.01 - 18-Feb-1994
  12. //     Version 2.00 - 10-Sep-1996   modified by Rob Lichtefeld
  13. //----------------------------------------------------------
  14.  
  15. #include <windows.h>
  16. #include <windowsx.h>
  17. #include "vbapi.h"
  18.  
  19. // Disable some warnings that won't go away.
  20. #pragma warning(disable: 4704 4785)
  21.  
  22. // Error codes we return.
  23. #define ERR_CANTLOADLIBRARY  30001
  24. #define ERR_CANTFINDFUNCTION 30002
  25. #define ERR_INVALIDPARMSTRING 30003 
  26. #define ERR_NOTNT 30004 
  27. #define ERR_INVALIDHWND 30005
  28. #define ERR_OOM  7
  29.  
  30. // Test for the error messages.
  31. char * szCantLoadLibrary = "Can't load DLL: \"%s\"\n(error=%d)";
  32. char * szCantFindFunction = "Can't find specified function";
  33. char * szInvalidParmString = "Invalid parameter definition string";
  34. // new
  35. char * szNotNT = "Not running on a 32-bit version of Windows";
  36. char * szInvalidHwnd = "Invalid window handle";
  37.  
  38. // This structure describes a function which has been 
  39. // registered with us.
  40. typedef struct {
  41.   DWORD hinst;        // 32-bit instance handle of library
  42.   LPVOID lpfunc;      // 32-bit function address of function
  43.   DWORD  dwAddrXlat;   // bit mask of params: 1 indicates arg is address
  44.   DWORD  dwHwndXlat;   // bit mask of params: 1 indicates arg is 16-bit hwnd
  45.   DWORD  nParams;      // number of parameters
  46.   // --- new
  47.   HANDLE hTask;        // task handle of 16-bit calling program
  48. } PROC32ENTRY;
  49.   
  50. // rgProc32Entry points to an array of PROC32ENTRY functions, which
  51. // is grown as needed.  The value returned by Declare32 is an
  52. // index into this array.
  53. int cRegistered = 0;  // number of registered functions.
  54. int cAlloc = 0;       // number of alloced PROC32ENTRY structures.
  55. PROC32ENTRY FAR * rgProc32Entry = 0;  // array of PROC32ENTRY structures.
  56. #define CALLOCGROW 10 // number of entries to grow rgProc32Entry by
  57.  
  58. // These are the addresses of the Generic Thunk functions in 
  59. // the WOW KERNEL.  
  60. BOOL fGotProcs = FALSE;    // Did we successfully get the addresses?
  61. DWORD (FAR PASCAL *CallProc32W)() = 0;
  62. BOOL (FAR PASCAL *FreeLibrary32W)(DWORD) = 0;
  63. LPVOID (FAR PASCAL *GetProcAddress32W)(DWORD, LPCSTR) = 0;
  64. DWORD (FAR PASCAL *LoadLibraryEx32W)(LPSTR, DWORD, DWORD) = 0;
  65. LPVOID lpvGetLastError = 0;   // address of 32-bit GetLastError.
  66.  
  67. //-----------------------------------------------------
  68. // XlatHwnd
  69. //   Translates a 16-bit HWND into a 32-bit HWND.
  70. //   The HWND must be one in our 16-bit process.
  71. //   NULL is translated to NULL and doesn't cause
  72. //   and error.
  73. //
  74. //   Unfortunately, WOW does not export a function (in Kernel/Kernel32)
  75. //   for doing this, so our procedure is as follows:
  76. //   We do 16-bit SetCapture call to the window
  77. //   to set the capture, and then a 32-bit GetCapture
  78. //   call to get the 32-bit equivalent handle.  The
  79. //   capture is then restored to what it was beforehand.
  80. //
  81. //   May cause VB runtime error, and hence never return.
  82. //-----------------------------------------------------
  83. // --- original 
  84. //static void PASCAL NEAR XlatHwnd
  85. // --- new
  86. void _export PASCAL XlatHwnd
  87. (
  88.   DWORD FAR * phwnd   // Points to 16-bit HWND, on return
  89.                       // points to 32-bit HWND.
  90. )
  91. {
  92.   HWND hwnd16 = LOWORD(*phwnd);  // 16-bit hwnd
  93.   HWND hwndCapturePrev;          // window that has the capture
  94.   DWORD hwnd32;                  // 32-bit hwnd
  95.   static LPVOID lpvGetCapture;   // Address of 32-bit GetCapture
  96.  
  97.   // Check for valid 16-bit handle.   
  98.   if (*phwnd != (DWORD)(LONG)(SHORT)hwnd16) 
  99.     goto BadHwnd;
  100.   if (hwnd16 != NULL && !IsWindow(hwnd16))
  101.     goto BadHwnd;
  102.   
  103.   // Get Address of 32-bit GetCapture
  104.   if (! lpvGetCapture) {
  105.     DWORD hinstUser = LoadLibraryEx32W("user32", 0, 0);
  106.     if (hinstUser) {
  107.       lpvGetCapture = GetProcAddress32W(hinstUser, "GetCapture");
  108.       FreeLibrary32W(hinstUser);
  109.     }
  110.     if (!lpvGetCapture) {
  111.       VBSetErrorMessage(ERR_NOTNT, szNotNT);
  112.       VBRuntimeError(ERR_NOTNT);
  113.     }
  114.   }
  115.   
  116.   // Set capture to window, get capture to get 32-bit handle. 
  117.   // Be sure to restore capture afterward.
  118.   // NULL isn't translated
  119.   if (hwnd16) {
  120.     hwndCapturePrev = SetCapture(hwnd16);
  121.     hwnd32 = ((DWORD (FAR PASCAL *)(LPVOID, DWORD, DWORD)) CallProc32W) (lpvGetCapture, (DWORD)0, (DWORD)0);
  122.     if (hwndCapturePrev)
  123.       SetCapture(hwndCapturePrev);
  124.     else
  125.       ReleaseCapture();
  126.     if (!hwnd32) 
  127.       goto BadHwnd;
  128.   }    
  129.  
  130.   // Success - done.    
  131.   *phwnd = hwnd32;
  132.   return;  
  133.  
  134. BadHwnd:
  135.   // Error: couldn't translate HWND or bad HWND passed.
  136.   VBSetErrorMessage(ERR_INVALIDHWND, szInvalidHwnd);
  137.   VBRuntimeError(ERR_INVALIDHWND);
  138. }
  139.  
  140.   
  141. //-----------------------------------------------------
  142. // MungeArgs
  143. //   Modify the args array so it can be passed to
  144. //   to CallProc32W.  This uses the PROC32ENTRY structure
  145. //   to set up the arg list correctly on the stack
  146. //   so CallProc32W can be call.  HWND translation is
  147. //   performed.  The frame is changed as follows:
  148. //           In:                 Out:
  149. //            unused              number of params
  150. //   dwArgs-> unused              address xlat mask
  151. //            PROC32ENTRY index   32-bit function address.
  152. //            argument            argument, possible HWND xlated
  153. //            argument            argument, possible HWND xlated
  154. //            ...                 ...
  155. //-----------------------------------------------------
  156. void PASCAL NEAR _loadds MungeArgs
  157. (
  158.   LPDWORD dwArgs           // Points to arg list
  159. )
  160. {
  161.   PROC32ENTRY FAR * pentry = & rgProc32Entry[dwArgs[1]];
  162.   int iArg = 2;
  163.   DWORD dwHwndXlat;
  164.   
  165.   dwArgs[-1] = pentry->nParams;
  166.   dwArgs[0] = pentry->dwAddrXlat;
  167.   dwArgs[1] = (DWORD) pentry->lpfunc;
  168.   dwHwndXlat = pentry->dwHwndXlat;
  169.   while (dwHwndXlat) {
  170.     if (dwHwndXlat & 1) 
  171.       XlatHwnd(& dwArgs[iArg]);
  172.     ++iArg;
  173.     dwHwndXlat >>= 1;
  174.   }  
  175. } 
  176.  
  177. //-----------------------------------------------------
  178. // Call32
  179. //   This function is called by VB applications directly.
  180. //   Arguments to the function are also on the stack 
  181. //   (iProc is the PROC32ENTRY index).  We correctly
  182. //   set up the stack frame, then JUMP to CallProc32W,
  183. //   which eventually returns to the user.
  184. //-----------------------------------------------------
  185. void _export PASCAL Call32(long iProc)
  186. {
  187.   __asm {
  188.   
  189.   pop     cx              // dx = callers DS
  190.   pop     bp              // restore BP
  191.   
  192.   mov     bx, sp          // bx = sp on entry
  193.   sub     sp, 8           // 2 additional words
  194.   mov     ax, ss:[bx]     // ax = return address offst
  195.   mov     dx, ss:[bx+2]   // dx = return address segment
  196.   mov     ss:[bx-8], ax
  197.   mov     ss:[bx-6], dx
  198.   push    ds              // Save our DS
  199.   push    ss
  200.   push    bx              // Push pointer to args
  201.   mov     ds, cx          // Restore caller's DS
  202.   call    MungeArgs       // Munge the args
  203.   pop     es              // es is our DS
  204.   jmp    far ptr es:[CallProc32W] // Jump to the call thunker
  205.   }
  206. }  
  207.  
  208. //-----------------------------------------------------
  209. // Declare32
  210. //   This function is called directly from VB.
  211. //   It allocates and fills in a PROC32ENTRY structure
  212. //   so that we can call the 32 bit function.
  213. //-----------------------------------------------------
  214. long _export PASCAL Declare32
  215. (
  216.   LPSTR lpstrName,       // function name
  217.   LPSTR lpstrLib,        // function library
  218.   LPSTR lpstrArg         // string indicating arg types
  219. )
  220. {
  221.   DWORD hinst;           // 32-bit DLL instance handle
  222.   LPVOID lpfunc;         // 32-bit function pointer
  223.   DWORD dwAddrXlat;      // address xlat mask
  224.   DWORD dwHwndXlat;      // hwnd xlat mask
  225.   DWORD nParams;         // number of params
  226.   CHAR szBuffer[128];    // scratch buffer
  227.  
  228.   // First time called, get the addresses of the Generic Thunk
  229.   // functions.  Raise VB runtime error if can't (probably because
  230.   // we're not running on NT).  
  231.   if (!fGotProcs) {
  232.     HINSTANCE hinstKernel;    // Instance handle of WOW KERNEL.DLL
  233.     DWORD hinstKernel32;      // Instance handle of Win32 KERNEL32.DLL
  234.     
  235.     hinstKernel = LoadLibrary("KERNEL");
  236.     if (hinstKernel < HINSTANCE_ERROR) {
  237.       VBSetErrorMessage(ERR_NOTNT, szNotNT);
  238.       VBRuntimeError(ERR_NOTNT);
  239.     }
  240.     
  241.     CallProc32W = (DWORD (FAR PASCAL *)()) GetProcAddress(hinstKernel, "CALLPROC32W");
  242.     FreeLibrary32W = (BOOL (FAR PASCAL *)(DWORD)) GetProcAddress(hinstKernel, "FREELIBRARY32W");
  243.     LoadLibraryEx32W =  (DWORD (FAR PASCAL *)(LPSTR, DWORD, DWORD))GetProcAddress(hinstKernel, "LOADLIBRARYEX32W");
  244.     GetProcAddress32W = (LPVOID (FAR PASCAL *)(DWORD, LPCSTR))  GetProcAddress(hinstKernel, "GETPROCADDRESS32W");
  245.     FreeLibrary(hinstKernel);
  246.  
  247.     if (LoadLibraryEx32W && GetProcAddress32W && FreeLibrary32W) {
  248.       hinstKernel32 = LoadLibraryEx32W("kernel32", 0, 0);
  249.       lpvGetLastError = GetProcAddress32W(hinstKernel32, "GetLastError");
  250.       FreeLibrary32W(hinstKernel32);
  251.     }
  252.     
  253.     if (!CallProc32W || !FreeLibrary32W || !LoadLibraryEx32W || 
  254.         !GetProcAddress32W || !lpvGetLastError) {
  255.       VBSetErrorMessage(ERR_NOTNT, szNotNT);
  256.       VBRuntimeError(ERR_NOTNT);
  257.     }
  258.     
  259.     fGotProcs = TRUE;
  260.   }  
  261.  
  262.   // If needed, allocate a PROC32ENTRY structure
  263.   if (cRegistered == cAlloc) {
  264.     if (rgProc32Entry) 
  265.       rgProc32Entry = (PROC32ENTRY FAR *) GlobalReAllocPtr(rgProc32Entry, 
  266.                                           (cAlloc + CALLOCGROW) * sizeof(PROC32ENTRY), GMEM_MOVEABLE | GMEM_SHARE);
  267.     else                                          
  268.       rgProc32Entry = (PROC32ENTRY FAR *) GlobalAllocPtr(GMEM_MOVEABLE | GMEM_SHARE, CALLOCGROW * sizeof(PROC32ENTRY));
  269.     if (!rgProc32Entry) {
  270.       VBRuntimeError(ERR_OOM);
  271.     }
  272.     cAlloc += CALLOCGROW;
  273.   }  
  274.   
  275.   // Process the arg list descriptor string to 
  276.   // get the hwnd and addr translation masks, and the
  277.   // number of args.
  278.   dwAddrXlat = dwHwndXlat = 0;
  279.   if ((nParams = lstrlen(lpstrArg)) > 32) {
  280.     VBSetErrorMessage(ERR_INVALIDPARMSTRING, szInvalidParmString);
  281.     VBRuntimeError(ERR_INVALIDPARMSTRING);
  282.   }
  283.   while (*lpstrArg) {
  284.     dwAddrXlat <<= 1;
  285.     dwHwndXlat <<= 1;
  286.     switch (*lpstrArg) {
  287.     case 'p':
  288.       dwAddrXlat |= 1;
  289.       break;
  290.     case 'i':
  291.       break;
  292.     case 'w':
  293.       dwHwndXlat |= 1;
  294.       break;
  295.     default:
  296.       VBSetErrorMessage(ERR_INVALIDPARMSTRING, szInvalidParmString);
  297.       VBRuntimeError(ERR_INVALIDPARMSTRING);
  298.     }
  299.     ++lpstrArg;
  300.   }
  301.   
  302.   // Load the 32-bit library.  
  303.   hinst = LoadLibraryEx32W(lpstrLib, NULL, 0);
  304.   if (!hinst) {
  305.     DWORD errCode = 0;
  306.  
  307.     // Get NT error code (szBuffer is convenient scratch buffer)    
  308.     errCode = ((DWORD (FAR PASCAL *)(LPVOID, DWORD, DWORD)) CallProc32W) (lpvGetLastError, (DWORD)0, (DWORD)0);
  309.     wsprintf(szBuffer, szCantLoadLibrary, lpstrLib, errCode);
  310.     VBSetErrorMessage(ERR_CANTLOADLIBRARY, szBuffer);
  311.     VBRuntimeError(ERR_CANTLOADLIBRARY);
  312.   }
  313.   
  314.   // Get the 32-bit function address.  Try the following three
  315.   // variations of the name (example: NAME):
  316.   //    NAME
  317.   //    _NAME@nn     (stdcall naming convention: nn is bytes of args)
  318.   //    NAMEA        (Win32 ANSI function naming convention)
  319.   lpfunc = GetProcAddress32W(hinst, lpstrName); 
  320.   if (!lpfunc && lstrlen(lpstrName) < 122) {
  321.     // Change to stdcall naming convention.
  322.     wsprintf(szBuffer, "_%s@%d", lpstrName, nParams * 4);
  323.     lpfunc = GetProcAddress32W(hinst, szBuffer);
  324.   }  
  325.   if (!lpfunc && lstrlen(lpstrName) < 126) {
  326.     // Add suffix "A" for ansi
  327.     lstrcpy(szBuffer, lpstrName);
  328.     lstrcat(szBuffer, "A");
  329.     lpfunc = GetProcAddress32W(hinst, szBuffer);
  330.   }  
  331.   if (!lpfunc) {
  332.     FreeLibrary32W(hinst);
  333.     VBSetErrorMessage(ERR_CANTFINDFUNCTION, szCantFindFunction);
  334.     VBRuntimeError(ERR_CANTFINDFUNCTION);
  335.   }
  336.   
  337.   // Fill in PROC32ENTRY struct and return index.     
  338.   rgProc32Entry[cRegistered].hinst = hinst;
  339.   rgProc32Entry[cRegistered].lpfunc = lpfunc;
  340.   rgProc32Entry[cRegistered].dwAddrXlat = dwAddrXlat;
  341.   rgProc32Entry[cRegistered].dwHwndXlat = dwHwndXlat;
  342.   rgProc32Entry[cRegistered].nParams = nParams;
  343.   // --- new by RAL
  344.   rgProc32Entry[cRegistered].hTask = GetCurrentTask();
  345.   return cRegistered++;
  346. }
  347.  
  348. // --- new procedures
  349. //-----------------------------------------------------
  350. // FreeCall32IDs
  351. //   This function is called directly from VB.
  352. //   It frees all the libraries that were loaded in the 
  353. //   Declare32 function for this Task Handle
  354. //
  355. // Writted by Rob Lichtefeld
  356. //-----------------------------------------------------
  357. void _export PASCAL FreeCall32IDs ()
  358. {
  359.    int iProc = cRegistered;
  360.    HANDLE ThisTask = GetCurrentTask();
  361.    while (--iProc >= 0) {
  362.       if (rgProc32Entry[iProc].hTask == ThisTask) {
  363.          if (rgProc32Entry[iProc].hinst != NULL) {
  364.             FreeLibrary32W(rgProc32Entry[iProc].hinst);
  365.             rgProc32Entry[iProc].hinst = NULL;
  366.          }
  367.          rgProc32Entry[iProc].hTask = NULL;
  368.       }
  369.    }
  370. }
  371.  
  372. //-----------------------------------------------------
  373. // WEP
  374. //   Called when DLL is unloaded.  
  375. //   clears the PROC32ENTRY list and frees the memory
  376. //-----------------------------------------------------
  377. int FAR PASCAL _export WEP(int nExitType)
  378. {
  379.   // --- removed from .DLL
  380.   // --- better to never free the libraries than to cause a Win95
  381.   // --- exception error
  382.   //while (--cRegistered >= 0) {
  383.   //  if (rgProc32Entry[cRegistered].hinst != NULL) {
  384.   //     FreeLibrary32W(rgProc32Entry[cRegistered].hinst);
  385.   //  }
  386.   //}
  387.   // --- end of removed section
  388.   if (rgProc32Entry)  
  389.     GlobalFreePtr(rgProc32Entry);
  390.   rgProc32Entry = NULL;
  391.   cRegistered = cAlloc = 0;
  392.   return 1;
  393. }
  394.