home *** CD-ROM | disk | FTP | other *** search
/ Looney Tunes Photo Fun / LooneyTunesPhotoFun.iso / Daosdk / DISK4 / DAOSDK.1 / regadll.c < prev    next >
C/C++ Source or Header  |  1998-04-06  |  6KB  |  283 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. // it's on the system
  121. // 
  122. BOOL WINAPI IsDLLInstalled( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  123. {
  124.     HINSTANCE    hModule;
  125.     CTLREGPROC    DLLUnregisterProc = NULL;
  126.  
  127.     //Gotta have good pointers
  128.     assert(pszPath != NULL) ;
  129.     assert(lplValue != NULL) ;
  130.  
  131.     //Assume it's OK
  132.     *lplValue = 0L;    
  133.  
  134.     //Load the DLL into memory
  135.     hModule = LoadLibrary((LPCSTR)pszPath) ;
  136.     
  137.     if (hModule == NULL) // Load failed, couldn't get the DLL
  138.         {
  139.         *lplValue = 1L;
  140.         return 0;
  141.         }
  142.             
  143.     FreeLibrary(hModule) ;          
  144.  
  145.     return 1;    
  146. }
  147.  
  148. //
  149. // Opens the specified DLL to determine if 
  150. // if the DLL is currently being used by another process
  151. // 
  152.  
  153. BOOL WINAPI IsDLLRunning( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  154. {
  155.     HANDLE hFile;
  156.     
  157.     assert(pszPath != NULL);
  158.  
  159.     //Try to open the file - exclusively. Assume that a failure
  160.     //indicates that the file is currently running
  161.     hFile =  CreateFile(
  162.         pszPath,    // address of name of the file 
  163.         GENERIC_READ | GENERIC_WRITE,    // access (read-write) mode 
  164.         0,    // share mode (none)
  165.         NULL,    // address of security descriptor 
  166.         OPEN_EXISTING,    // how to create 
  167.         FILE_ATTRIBUTE_NORMAL,    // file attributes 
  168.         NULL     // handle of file with attributes to copy  
  169.            );    
  170.      
  171.      //If couldn't get a handle...
  172.      if(hFile == INVALID_HANDLE_VALUE)
  173.          {
  174.         //If the file exists then it must be locked by another process
  175.         if(GetFileAttributes(pszPath) != 0xFFFFFFFF)
  176.             {
  177.             CloseHandle(hFile);
  178.             *lplValue = 1L;
  179.             return TRUE;
  180.             }
  181.         }
  182.  
  183.     //It's not in use
  184.     CloseHandle(hFile);
  185.     *lplValue = 0L;
  186.     return FALSE;
  187. }
  188.  
  189.  
  190. //
  191. // Opens the OLEAUT32.DLL and looks for the UnregisterTypeLib function 
  192. // and returns an error if it's not present
  193. // 
  194.  
  195. BOOL WINAPI CheckOLEAut( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  196. {
  197.     HINSTANCE    hModule;
  198.     CTLREGPROC    DLLUnregisterProc = NULL;
  199.  
  200.     //Gotta have good pointers
  201.     assert(pszPath != NULL) ;
  202.     assert(lplValue != NULL) ;
  203.  
  204.     //Assume it's OK
  205.     *lplValue = 0L;    
  206.  
  207.     //Load the DLL into memory
  208.     hModule = LoadLibrary((LPCSTR)pszPath) ;
  209.  
  210.     
  211.     if (hModule == NULL) // Load failed, couldn't get the DLL
  212.         {
  213.         *lplValue = 1L;
  214.         return 0;
  215.         }
  216.             
  217.     //Get a pointer to the UNRegister function
  218.     DLLUnregisterProc = (CTLREGPROC)GetProcAddress(hModule,"UnRegisterTypeLib" ) ;
  219.             
  220.     if (DLLUnregisterProc == NULL)
  221.         {
  222.         *lplValue = 1L;    
  223.         }
  224.  
  225.     FreeLibrary(hModule) ;          
  226.  
  227.     return 1;    
  228. }
  229.  
  230. //
  231. // Runs the specified executable
  232. // 
  233. // 
  234.  
  235. BOOL WINAPI RunProcess( HWND hwndMain, LPLONG lplValue, LPSTR pszPath )
  236. {
  237.     BOOL                bLaunched;
  238.     PROCESS_INFORMATION    pi;
  239.     STARTUPINFO            si;    
  240.  
  241.     assert(pszPath != NULL);
  242.  
  243.     //Fill in the startup info
  244.     si.cb = sizeof(si);
  245.     si.lpReserved = NULL;
  246.     si.lpDesktop = NULL;
  247.     si.lpTitle = NULL;
  248.     si.dwX = 0;
  249.     si.dwY = 0;
  250.     si.dwXSize = 0;
  251.     si.dwYSize = 0;
  252.     si.dwXCountChars = 0;
  253.     si.dwYCountChars = 0;
  254.     si.dwFillAttribute = 0;
  255.     si.dwFlags = STARTF_FORCEOFFFEEDBACK;
  256.     si.wShowWindow = 0;
  257.     si.cbReserved2 = 0;
  258.     si.lpReserved2 = NULL;
  259.     si.hStdInput = 0;
  260.     si.hStdOutput = 0;
  261.     si.hStdError = 0;
  262.     
  263.     //Run the specified process
  264.     bLaunched = CreateProcess(pszPath,    // pointer to name of executable module 
  265.             NULL,
  266.             NULL,
  267.             NULL,
  268.             FALSE,    
  269.             CREATE_DEFAULT_ERROR_MODE | HIGH_PRIORITY_CLASS,
  270.             NULL,
  271.             NULL,            
  272.             &si,
  273.             &pi);
  274.  
  275.     if(bLaunched)
  276.         {
  277.         //Give the process 10 seconds to complete
  278.         WaitForInputIdle(pi.hProcess, 10000);
  279.         }
  280.  
  281.     return bLaunched;
  282. }
  283.