home *** CD-ROM | disk | FTP | other *** search
/ Supercompiler 1997 / SUPERCOMPILER97.iso / MS_DAO.SDK / DISK4 / DAOSDK.1 / regadll.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-08  |  5.0 KB  |  235 lines
  1. //
  2. //
  3. //    File:        RegADLL.c
  4. //
  5. //    Purpose:    Call DLLRegisterServer/UnRegisterServer in a 
  6. //                specified DLL.
  7. //                Needed as a buffer between InstallShield and the
  8. //                DLL itself
  9. //
  10. //
  11.  
  12. #include  <windows.h>
  13. #include  <assert.h>
  14. #include  <VER.H>
  15. #include  "RegADLL.h"
  16.  
  17. BOOL WINAPI LibMain ( HINSTANCE hInstDLL, DWORD dwReason, LPVOID lpvReserved )
  18. {
  19.         return (TRUE);
  20.         UNREFERENCED_PARAMETER( hInstDLL );
  21.         UNREFERENCED_PARAMETER( dwReason );
  22.         UNREFERENCED_PARAMETER( lpvReserved );
  23. }
  24.  
  25.  
  26. INT WINAPI RegisterADLL( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  27. {
  28.     HINSTANCE    hModule;
  29.     CTLREGPROC    DLLRegisterServer;
  30.     HRESULT        regResult;
  31.     BOOL        bResult = FALSE;
  32.  
  33.     //Gotta have good pointers
  34.     assert(pszPath != NULL) ;
  35.     assert(lplValue != NULL) ;
  36.     
  37.     //Load the DLL into memory
  38.     hModule = LoadLibrary(pszPath) ;
  39.     
  40.     if (hModule == NULL) // Load failed, couldn't get the DLL
  41.         {
  42.         *lplValue = 0L;
  43.         MessageBox(NULL, "Couldn't find DLL", pszPath, MB_ICONEXCLAMATION);
  44.         return 1;
  45.         }
  46.             
  47.     //Get a pointer to the Register function
  48.     DLLRegisterServer = (CTLREGPROC)GetProcAddress(hModule,"DllRegisterServer" ) ;
  49.     
  50.     if (DLLRegisterServer != NULL)
  51.         {
  52.         regResult = DLLRegisterServer() ;
  53.         bResult = (regResult == NOERROR) ; 
  54.         }        
  55.     else
  56.         {
  57.         MessageBox(NULL, "Missing server registration function", pszPath, MB_ICONEXCLAMATION);
  58.         }
  59.     FreeLibrary(hModule) ;          
  60.  
  61.     //Everything went OK?
  62.     *lplValue = bResult ? 1L:0L;
  63.     
  64.  
  65.     return 1;    
  66. }
  67.  
  68.  
  69. INT WINAPI UnRegisterADLL( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  70. {
  71.     HINSTANCE    hModule;
  72.     CTLREGPROC    DLLUnregisterServer;
  73.     HRESULT        regResult;
  74.     BOOL        bResult = FALSE;
  75.     CHAR        szBuf[256];
  76.  
  77.     //Gotta have good pointers
  78.     assert(pszPath != NULL) ;
  79.     assert(lplValue != NULL) ;
  80.     
  81.     //Load the DLL into memory
  82.     hModule = LoadLibrary((LPCSTR)pszPath) ;
  83.     
  84.     if (hModule == NULL) // Load failed, couldn't get the DLL
  85.         {
  86.         *lplValue = 0L;
  87.         MessageBox(NULL, "Can't find DLL", pszPath, MB_ICONEXCLAMATION);
  88.         return 1;
  89.         }
  90.             
  91.     //Get a pointer to the UNRegister function
  92.     DLLUnregisterServer = (CTLREGPROC)GetProcAddress(hModule,"DllUnregisterServer" ) ;
  93.             
  94.     if (DLLUnregisterServer != NULL)
  95.         {
  96.         regResult = DLLUnregisterServer() ;
  97.         bResult = (regResult == NOERROR) ; 
  98.         }        
  99.     else
  100.         {
  101.         MessageBox(NULL, "Missing server Unregistration function", pszPath, MB_ICONEXCLAMATION);
  102.         }
  103.     FreeLibrary(hModule) ;          
  104.  
  105.     //Everything went OK?
  106.     *lplValue = bResult ? 1L:0L;
  107.     
  108.     if (!bResult)
  109.         {
  110.         wsprintf(szBuf, "Unregistration failed - DLLUnregisterServer returned %d", regResult);
  111.         MessageBox(NULL, szBuf, pszPath, MB_OK);
  112.         }
  113.     
  114.     return 1;    
  115.  
  116. } 
  117.  
  118. //
  119. // Opens the specified DLL to determine if 
  120. // if the DLL is currently being used by another process
  121. // 
  122.  
  123. BOOL WINAPI IsDLLRunning( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  124. {
  125.     HANDLE hFile;
  126.     
  127.     assert(pszPath != NULL);
  128.  
  129.     //Try to open the file - exclusively. Assume that a failure
  130.     //indicates that the file is currently running
  131.     hFile =  CreateFile(
  132.         pszPath,    // address of name of the file 
  133.         GENERIC_READ | GENERIC_WRITE,    // access (read-write) mode 
  134.         0,    // share mode (none)
  135.         NULL,    // address of security descriptor 
  136.         OPEN_EXISTING,    // how to create 
  137.         FILE_ATTRIBUTE_NORMAL,    // file attributes 
  138.         NULL     // handle of file with attributes to copy  
  139.            );    
  140.      
  141.      //If couldn't get a handle...
  142.      if(hFile == INVALID_HANDLE_VALUE)
  143.          {
  144.         //If the file exists then it must be locked by another process
  145.         if(GetFileAttributes(pszPath) != 0xFFFFFFFF)
  146.             {
  147.             CloseHandle(hFile);
  148.             *lplValue = 1L;
  149.             return TRUE;
  150.             }
  151.         }
  152.  
  153.     //It's not in use
  154.     CloseHandle(hFile);
  155.     *lplValue = 0L;
  156.     return FALSE;
  157. }
  158.  
  159.  
  160. //
  161. // Runs the specified executable
  162. // 
  163. // 
  164.  
  165. BOOL WINAPI RunProcess( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  166. {
  167.     BOOL                bLaunched;
  168.     PROCESS_INFORMATION    pi;
  169.     STARTUPINFO            si;    
  170.  
  171.     assert(pszPath != NULL);
  172.  
  173.     //Fill in the startup info
  174.     si.cb = sizeof(si);
  175.     si.lpReserved = NULL;
  176.     si.lpDesktop = NULL;
  177.     si.lpTitle = NULL;
  178.     si.dwX = 0;
  179.     si.dwY = 0;
  180.     si.dwXSize = 0;
  181.     si.dwYSize = 0;
  182.     si.dwXCountChars = 0;
  183.     si.dwYCountChars = 0;
  184.     si.dwFillAttribute = 0;
  185.     si.dwFlags = STARTF_FORCEOFFFEEDBACK;
  186.     si.wShowWindow = 0;
  187.     si.cbReserved2 = 0;
  188.     si.lpReserved2 = NULL;
  189.     si.hStdInput = 0;
  190.     si.hStdOutput = 0;
  191.     si.hStdError = 0;
  192.     
  193.     //Run the specified process
  194.     bLaunched = CreateProcess(pszPath,    // pointer to name of executable module 
  195.             NULL,
  196.             NULL,
  197.             NULL,
  198.             FALSE,    
  199.             CREATE_DEFAULT_ERROR_MODE | HIGH_PRIORITY_CLASS,
  200.             NULL,
  201.             NULL,            
  202.             &si,
  203.             &pi);
  204.  
  205.     if(bLaunched)
  206.         {
  207.         //Give the process 10 seconds to complete
  208.         WaitForInputIdle(pi.hProcess, 10000);
  209.         }
  210.  
  211.     return bLaunched;
  212. }
  213.  
  214.  
  215.  
  216. //
  217. // Is this Win95 J (japan)
  218. // 
  219. // 
  220. #define    MS_LANGID_JPN    0x0411
  221.  
  222. BOOL WINAPI IsWinJ( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  223. {
  224.  
  225. if(GetSystemDefaultLangID() == MS_LANGID_JPN)
  226.     {
  227.     *lplValue = 1L;
  228.     return TRUE;
  229.     }
  230.  
  231. *lplValue = 0L;
  232. return FALSE;
  233.  
  234. }
  235.