diff options
Diffstat (limited to 'utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp')
| -rw-r--r-- | utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp | 1043 |
1 files changed, 1043 insertions, 0 deletions
diff --git a/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp new file mode 100644 index 0000000..6a22176 --- /dev/null +++ b/utils/vmpi/vmpi_service_install/ServiceInstallDlg.cpp @@ -0,0 +1,1043 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +// JobWatchDlg.cpp : implementation file +// + +#include "stdafx.h" +#include "ServiceInstallDlg.h" +#include "tier1/strtools.h" + + +#define DEFAULT_INSTALL_LOCATION "C:\\Program Files\\Valve\\vmpi_service" + +#define HLKM_WINDOWS_RUN_KEY "Software\\Microsoft\\Windows\\CurrentVersion\\Run" +#define VMPI_SERVICE_VALUE_NAME "VMPI Service" +#define VMPI_SERVICE_UI_VALUE_NAME "VMPI Service UI" + +// These are the files required for installation. +char *g_pInstallFiles[] = +{ + "vmpi_service.exe", + "vmpi_service_ui.exe", + "WaitAndRestart.exe", + "vmpi_service_install.exe", + "tier0.dll", + "vmpi_transfer.exe", + "filesystem_stdio.dll", + "vstdlib.dll" +}; + + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +HWND g_hMessageControl = NULL; +HKEY g_hVMPIKey = NULL; // hklm/software/valve/vmpi. +bool g_bNoOutput = false; +bool g_bDontTouchUI = false; +bool g_bReinstalling = false; + +FILE *g_fpLog = NULL; + + +char* FindArg( int argc, char **argv, const char *pArgName, char *pDefaultValue="" ) +{ + for ( int i=0; i < argc; i++ ) + { + if ( stricmp( argv[i], pArgName ) == 0 ) + { + if ( (i+1) >= argc ) + return pDefaultValue; + else + return argv[i+1]; + } + } + return NULL; +} + +void CloseLog() +{ + if ( g_fpLog ) + { + fflush( g_fpLog ); + fclose( g_fpLog ); + flushall(); + g_fpLog = NULL; + } +} + +void OpenLog() +{ + CloseLog(); + g_fpLog = fopen( "c:\\vmpi_service_install.log", "wt" ); +} + + +void AddToLog( const char *pMsg ) +{ + if ( g_fpLog ) + { + fprintf( g_fpLog, "%s", pMsg ); + } +} + + +SpewRetval_t MySpewOutputFunc( SpewType_t spewType, const tchar *pMsg ) +{ + AddToLog( pMsg ); + + if ( spewType == SPEW_MESSAGE || spewType == SPEW_WARNING ) + { + // Format the message and send it to the control. + CUtlVector<char> msg; + msg.SetSize( V_strlen( pMsg )*2 + 1 ); + + char *pOut = msg.Base(); + const char *pIn = pMsg; + while ( *pIn ) + { + if ( *pIn == '\n' ) + { + *pOut++ = '\r'; + *pOut++ = '\n'; + } + else + { + *pOut++ = *pIn; + } + ++pIn; + } + *pOut = 0; + + int nLen = (int)SendMessage( g_hMessageControl, EM_GETLIMITTEXT, 0, 0 ); + SendMessage( g_hMessageControl, EM_SETSEL, nLen, nLen ); + SendMessage( g_hMessageControl, EM_REPLACESEL, FALSE, (LPARAM)msg.Base() ); + } + + // Show a message box for warnings and errors. + if ( spewType == SPEW_ERROR || spewType == SPEW_WARNING ) + { + if ( !g_bNoOutput ) + AfxMessageBox( pMsg, MB_OK ); + } + + if ( spewType == SPEW_ERROR ) + { + CloseLog(); + TerminateProcess( GetCurrentProcess(), 2 ); + } + + return SPEW_CONTINUE; +} + + +void ScanDirectory( const char *pDirName, CUtlVector<CString> &subDirs, CUtlVector<CString> &files ) +{ + subDirs.Purge(); + files.Purge(); + + char strPattern[MAX_PATH]; + V_ComposeFileName( pDirName, "*.*", strPattern, sizeof( strPattern ) ); + + WIN32_FIND_DATA fileInfo; // File information + HANDLE hFile = ::FindFirstFile( strPattern, &fileInfo ); + if ( hFile == INVALID_HANDLE_VALUE ) + return; + + do + { + if ( fileInfo.cFileName[0] == '.' ) + continue; + + if ( fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + subDirs.AddToTail( fileInfo.cFileName ); + else + files.AddToTail( fileInfo.cFileName ); + } while( ::FindNextFile(hFile, &fileInfo) ); + + ::FindClose( hFile ); +} + + +int DeleteDirectory( const char *pRootDir, bool bDeleteSubdirectories, char errorFile[MAX_PATH] ) +{ + errorFile[0] = 0; + + CUtlVector<CString> subDirs, files; + ScanDirectory( pRootDir, subDirs, files ); + + // First nuke any subdirectories. + if ( bDeleteSubdirectories && !g_bReinstalling ) + { + for ( int i=0; i < subDirs.Count(); i++ ) + { + char fullName[MAX_PATH]; + V_ComposeFileName( pRootDir, subDirs[i], fullName, sizeof( fullName ) ); + + // Delete subdirectory + int iRC = DeleteDirectory( fullName, bDeleteSubdirectories, errorFile ); + if ( iRC ) + return iRC; + } + } + + for ( int i=0; i < files.Count(); i++ ) + { + char fullName[MAX_PATH]; + V_ComposeFileName( pRootDir, files[i], fullName, sizeof( fullName ) ); + + // Set file attributes + if ( !SetFileAttributes( fullName, FILE_ATTRIBUTE_NORMAL ) ) + return GetLastError(); + + // Delete file + if ( !DeleteFile( fullName ) ) + { + V_strncpy( errorFile, fullName, MAX_PATH ); + return GetLastError(); + } + } + + if( !g_bReinstalling ) + { + // Set directory attributes + if ( !SetFileAttributes( pRootDir, FILE_ATTRIBUTE_NORMAL ) ) + return GetLastError(); + + // Delete directory + if ( !RemoveDirectory( pRootDir ) ) + return GetLastError(); + } + + return 0; +} + + +bool CreateDirectory_R( const char *pDirName ) +{ + char chPrevDir[MAX_PATH]; + V_strncpy( chPrevDir, pDirName, sizeof( chPrevDir ) ); + if ( V_StripLastDir( chPrevDir, sizeof( chPrevDir ) ) ) + { + if ( V_stricmp( chPrevDir, ".\\" ) != 0 && V_stricmp( chPrevDir, "./" ) != 0 ) + if ( !CreateDirectory_R( chPrevDir ) ) + return false; + } + + if ( _access( pDirName, 0 ) == 0 ) + return true; + + return CreateDirectory( pDirName, NULL ) || GetLastError() == ERROR_ALREADY_EXISTS; +} + + +bool SetupStartMenuSubFolderName( const char *pSubFolderName, char *pOut, int outLen ) +{ + LPITEMIDLIST pidl; + + // Get a pointer to an item ID list that represents the path of a special folder + HRESULT hr = SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_PROGRAMS, &pidl); + if ( hr != S_OK ) + return false; + + // Convert the item ID list's binary representation into a file system path + char szPath[_MAX_PATH]; + BOOL f = SHGetPathFromIDList(pidl, szPath); + + // Free the LPITEMIDLIST they gave us. + LPMALLOC pMalloc; + hr = SHGetMalloc(&pMalloc); + pMalloc->Free(pidl); + pMalloc->Release(); + + if ( f ) + { + V_ComposeFileName( szPath, pSubFolderName, pOut, outLen ); + return true; + } + else + { + return false; + } +} + +bool CreateStartMenuLink( const char *pSubFolderName, const char *pLinkName, const char *pLinkTarget, const char *pArguments ) +{ + char fullFolderName[MAX_PATH]; + if ( !SetupStartMenuSubFolderName( pSubFolderName, fullFolderName, sizeof( fullFolderName ) ) ) + return false; + + // Create the folder if necessary. + if ( !CreateDirectory_R( fullFolderName ) ) + { + Msg( "CreateStartMenuLink failed - can't create directory %s.\n", fullFolderName ); + return false; + } + + IShellLink* psl = NULL; + + // Get a pointer to the IShellLink interface. + bool bRet = false; + CoInitialize( NULL ); + HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, reinterpret_cast<void**>(&psl)); + if (SUCCEEDED(hres)) + { + psl->SetPath( pLinkTarget ); // Set the path to the shortcut target + if ( pArguments ) + psl->SetArguments( pArguments ); + + // Query IShellLink for the IPersistFile interface for saving + //the shortcut in persistent storage. + IPersistFile* ppf = NULL; + hres = psl->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&ppf) ); + if (SUCCEEDED(hres)) + { + // Setup the filename for the link. + char linkFilename[MAX_PATH]; + V_ComposeFileName( fullFolderName, pLinkName, linkFilename, sizeof( linkFilename ) ); + V_strncat( linkFilename, ".lnk", sizeof( linkFilename ) ); + + // Ensure that the string is ANSI. + WCHAR wsz[MAX_PATH]; + MultiByteToWideChar(CP_ACP, 0, linkFilename, -1, wsz, MAX_PATH); + + // Save the link by calling IPersistFile::Save. + hres = ppf->Save( wsz, TRUE ); + ppf->Release(); + bRet = true; + } + + psl->Release(); + } + CoUninitialize(); + return bRet; +} + + + +char* GetLastErrorString() +{ + static char err[2048]; + + LPVOID lpMsgBuf; + FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR) &lpMsgBuf, + 0, + NULL + ); + + strncpy( err, (char*)lpMsgBuf, sizeof( err ) ); + LocalFree( lpMsgBuf ); + + err[ sizeof( err ) - 1 ] = 0; + + return err; +} + + +bool LaunchApp( char *pCommandLine, const char *pBaseDir ) +{ + STARTUPINFO si; + memset( &si, 0, sizeof( si ) ); + si.cb = sizeof( si ); + + PROCESS_INFORMATION pi; + memset( &pi, 0, sizeof( pi ) ); + + return CreateProcess( NULL, pCommandLine, NULL, NULL, FALSE, 0, NULL, pBaseDir, &si, &pi ) != 0; +} + + +bool StartVMPIServiceUI( const char *pInstallLocation ) +{ + if ( g_bDontTouchUI ) + { + Msg( "StartVMPIServiceUI: Ignoring due to -DontTouchUI.\n" ); + return true; + } + + char cmdLine[MAX_PATH]; + V_ComposeFileName( pInstallLocation, "vmpi_service_ui.exe", cmdLine, sizeof( cmdLine ) ); + return LaunchApp( cmdLine, pInstallLocation ); +} + + +bool StartVMPIService( SC_HANDLE hSCManager ) +{ + bool bRet = true; + + // First, get rid of an old service with the same name. + SC_HANDLE hMyService = OpenService( hSCManager, VMPI_SERVICE_NAME_INTERNAL, SERVICE_START ); + if ( hMyService ) + { + if ( StartService( hMyService, NULL, NULL ) ) + { + Msg( "Started!\n" ); + } + else + { + Error( "Can't start the service.\n" ); + bRet = false; + } + } + else + { + Error( "Can't open service: %s\n", VMPI_SERVICE_NAME_INTERNAL ); + bRet = false; + } + + CloseServiceHandle( hMyService ); + return bRet; +} + + +bool StopRunningApp() +{ + if ( g_bDontTouchUI ) + { + Msg( "StopRunningApp: -DontTouchUI was specified, so exiting before stopping the app.\n" ); + return true; + } + + // Send the + ISocket *pSocket = CreateIPSocket(); + if ( pSocket ) + { + if ( pSocket->BindToAny( 0 ) ) + { + CUtlVector<char> protocolVersions; + protocolVersions.AddToTail( VMPI_PROTOCOL_VERSION ); + if ( VMPI_PROTOCOL_VERSION == 5 ) + protocolVersions.AddToTail( 4 ); // We want this installer to kill the previous services too. + + for ( int iProtocolVersion=0; iProtocolVersion < protocolVersions.Count(); iProtocolVersion++ ) + { + char cPacket[4] = + { + protocolVersions[iProtocolVersion], + VMPI_PASSWORD_OVERRIDE, // (force it to accept this message). + 0, + VMPI_STOP_SERVICE + }; + + CIPAddr addr( 127, 0, 0, 1, 0 ); + + for ( int iPort=VMPI_SERVICE_PORT; iPort <= VMPI_LAST_SERVICE_PORT; iPort++ ) + { + addr.port = iPort; + pSocket->SendTo( &addr, cPacket, sizeof( cPacket ) ); + } + } + + // Give it a sec to get the message and shutdown in case we're restarting. + Sleep( 2000 ); + + + // This is the overkill method. If it didn't shutdown gracefully, kill it. + HMODULE hInst = LoadLibrary( "psapi.dll" ); + if ( hInst ) + { + typedef BOOL (WINAPI *EnumProcessesFn)(DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded); + typedef BOOL (WINAPI *EnumProcessModulesFn)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded ); + typedef DWORD (WINAPI *GetModuleBaseNameFn)( HANDLE hProcess, HMODULE hModule, LPTSTR lpBaseName, DWORD nSize ); + + EnumProcessesFn EnumProcesses = (EnumProcessesFn)GetProcAddress( hInst, "EnumProcesses" ); + EnumProcessModulesFn EnumProcessModules = (EnumProcessModulesFn)GetProcAddress( hInst, "EnumProcessModules" ); + GetModuleBaseNameFn GetModuleBaseName = (GetModuleBaseNameFn)GetProcAddress( hInst, "GetModuleBaseNameA" ); + if ( EnumProcessModules && EnumProcesses ) + { + // Now just to make sure, kill the processes we're interested in. + DWORD procIDs[1024]; + DWORD nBytes; + if ( EnumProcesses( procIDs, sizeof( procIDs ), &nBytes ) ) + { + DWORD nProcs = nBytes / sizeof( procIDs[0] ); + for ( DWORD i=0; i < nProcs; i++ ) + { + HANDLE hProc = OpenProcess( PROCESS_ALL_ACCESS, FALSE, procIDs[i] ); + if ( hProc ) + { + HMODULE hModules[1024]; + if ( EnumProcessModules( hProc, hModules, sizeof( hModules ), &nBytes ) ) + { + DWORD nModules = nBytes / sizeof( hModules[0] ); + for ( DWORD iModule=0; iModule < nModules; iModule++ ) + { + char filename[512]; + if ( GetModuleBaseName( hProc, hModules[iModule], filename, sizeof( filename ) ) ) + { + if ( Q_stristr( filename, "vmpi_service.exe" ) || Q_stristr( filename, "vmpi_service_ui.exe" ) ) + { + TerminateProcess( hProc, 1 ); + CloseHandle( hProc ); + hProc = NULL; + break; + } + } + } + } + + CloseHandle( hProc ); + } + } + } + } + + FreeLibrary( hInst ); + } + } + + pSocket->Release(); + } + + return true; +} + + +bool StopOrDeleteService( SC_HANDLE hSCManager, bool bDelete ) +{ + bool bRet = true; + + // First, get rid of an old service with the same name. + SC_HANDLE hOldService = OpenService( hSCManager, VMPI_SERVICE_NAME_INTERNAL, SERVICE_STOP | DELETE ); + if ( hOldService ) + { + // Stop the service. + Msg( "Found the service already running.\n" ); + Msg( "Stopping service...\n" ); + SERVICE_STATUS status; + ControlService( hOldService, SERVICE_CONTROL_STOP, &status ); + + if ( bDelete ) + { + Msg( "Deleting service...\n" ); + bool bExitedNicely = false; + DWORD startTime = GetTickCount(); + while ( 1 ) + { + BOOL bRet = DeleteService( hOldService ); + if ( !bRet || bRet == ERROR_SERVICE_MARKED_FOR_DELETE ) + { + Msg( "Deleted old service.\n" ); + bExitedNicely = true; + break; + } + + // Wait for the service to stop for 8 seconds. + if ( GetTickCount() - startTime > 8000 ) + break; + } + + if ( !bExitedNicely ) + { + Error( "Couldn't delete the old '%s' service! Error: %s.\n", VMPI_SERVICE_NAME, GetLastErrorString() ); + bRet = false; + } + } + + CloseServiceHandle( hOldService ); + } + + return bRet; +} + + +bool GetExistingInstallationLocation( CString &strInstallLocation ) +{ + char buf[1024]; + DWORD bufSize = sizeof( buf ); + DWORD dwType; + if ( RegQueryValueEx( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY, NULL, &dwType, (LPBYTE)buf, &bufSize ) == ERROR_SUCCESS ) + { + if ( dwType == REG_SZ ) + { + strInstallLocation = buf; + return true; + } + } + + return false; +} + +void RemoveRegistryKeys() +{ + // Delete the run values (that tells it to run the app when the user logs in). + HKEY hKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, HLKM_WINDOWS_RUN_KEY, &hKey ); + RegDeleteValue( hKey, VMPI_SERVICE_VALUE_NAME ); + RegDeleteValue( hKey, VMPI_SERVICE_UI_VALUE_NAME ); + + // Get rid of the "InstallLocation" value. + RegDeleteValue( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY ); +} + + +bool IsAnInstallFile( const char *pName ) +{ + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + if ( V_stricmp( g_pInstallFiles[i], pName ) == 0 ) + return true; + } + return false; +} + + +bool AnyNonInstallFilesInDirectory( const char *strInstallLocation ) +{ + char searchStr[MAX_PATH]; + V_ComposeFileName( strInstallLocation, "*.*", searchStr, sizeof( searchStr ) ); + + _finddata_t data; + long handle = _findfirst( searchStr, &data ); + if ( handle != -1 ) + { + do + { + if ( data.name[0] == '.' || (data.attrib & _A_SUBDIR) != 0 ) + continue; + + if ( !IsAnInstallFile( data.name ) ) + return true; + + } while( _findnext( handle, &data ) == 0 ); + + _findclose( handle ); + } + return false; +} + + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallDlg dialog + + +CServiceInstallDlg::CServiceInstallDlg(CWnd* pParent /*=NULL*/) + : CDialog(CServiceInstallDlg::IDD, pParent) +{ + //{{AFX_DATA_INIT(CServiceInstallDlg) + // NOTE: the ClassWizard will add member initialization here + //}}AFX_DATA_INIT +} + + +CServiceInstallDlg::~CServiceInstallDlg() +{ +} + + +void CServiceInstallDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + //{{AFX_DATA_MAP(CServiceInstallDlg) + //}}AFX_DATA_MAP +} + + +BEGIN_MESSAGE_MAP(CServiceInstallDlg, CDialog) + //{{AFX_MSG_MAP(CServiceInstallDlg) + ON_BN_CLICKED(IDC_CANCEL_BUTTON, OnCancel) + ON_BN_CLICKED(IDC_INSTALL_BUTTON, OnInstall) + ON_BN_CLICKED(IDC_UNINSTALL_BUTTON2, OnUninstall) + ON_BN_CLICKED(IDC_START_EXISTING_BUTTON, OnStartExisting) + ON_BN_CLICKED(IDC_STOP_EXISTING_BUTTON, OnStopExisting) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +///////////////////////////////////////////////////////////////////////////// +// CServiceInstallDlg message handlers + +const char* FindArg( const char *pArgName, const char *pDefault="" ) +{ + for ( int i=1; i < __argc; i++ ) + { + if ( Q_stricmp( pArgName, __argv[i] ) == 0 ) + { + if ( (i+1) < __argc ) + return __argv[i+1]; + else + return pDefault; + } + } + return NULL; +} + + +BOOL CServiceInstallDlg::OnInitDialog() +{ + CDialog::OnInitDialog(); + + HICON hIcon = LoadIcon( AfxGetInstanceHandle(), MAKEINTRESOURCE( IDR_MAINFRAME ) ); + SetIcon( hIcon, true ); + + OpenLog(); + + // Setup the registry key for the install location. + if ( RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &g_hVMPIKey ) != ERROR_SUCCESS ) + { + Error( "Can't open registry key: %s.", VMPI_SERVICE_KEY ); + return FALSE; + } + + VerifyInstallFiles(); + + g_hMessageControl = ::GetDlgItem( GetSafeHwnd(), IDC_TEXTOUTPUT ); + SpewOutputFunc( MySpewOutputFunc ); + + // Init the service manager. + m_hSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); + if ( !m_hSCManager ) + { + Error( "OpenSCManager failed (%s)!\n", GetLastErrorString() ); + return FALSE; + } + + + // See if there is a previous installation. + CString strInstallLocation; + if ( GetExistingInstallationLocation( strInstallLocation ) ) + SetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ); + else + SetDlgItemText( IDC_INSTALL_LOCATION, DEFAULT_INSTALL_LOCATION ); + + // Now, if they passed in a command line option . + if ( FindArg( __argc, __argv, "-install_quiet" ) ) + { + g_bReinstalling = true; + g_bNoOutput = true; + g_bDontTouchUI = (FindArg( __argc, __argv, "-DontTouchUI", NULL ) != 0); + OnInstall(); + EndDialog( 0 ); + } + else if ( FindArg( __argc, __argv, "-uninstall_quiet" ) ) + { + g_bNoOutput = true; + DoUninstall( false ); + EndDialog( 0 ); + } + else if ( FindArg( __argc, __argv, "-start" ) ) + { + OnStartExisting(); + } + + else if ( FindArg( __argc, __argv, "-stop" ) ) + { + OnStopExisting(); + } + + return TRUE; // return TRUE unless you set the focus to a control + // EXCEPTION: OCX Property Pages should return FALSE +} + + +void CServiceInstallDlg::OnCancel(void) +{ + EndDialog( 1 ); +} + +// This function registers the service with the service manager. +bool InstallService( SC_HANDLE hSCManager, const char *pBaseDir ) +{ + char filename[512], uiFilename[512]; + V_ComposeFileName( pBaseDir, "vmpi_service.exe", filename, sizeof( filename ) ); + V_ComposeFileName( pBaseDir, "vmpi_service_ui.exe", uiFilename, sizeof( uiFilename ) ); + + + // Try a to reinstall the service for up to 5 seconds. + Msg( "Creating new service...\n" ); + + SC_HANDLE hMyService = NULL; + DWORD startTime = GetTickCount(); + while ( GetTickCount() - startTime < 5000 ) + { + // Now reinstall it. + hMyService = CreateService( + hSCManager, // Service Control Manager database. + VMPI_SERVICE_NAME_INTERNAL, // Service name. + VMPI_SERVICE_NAME, // Display name. + SERVICE_ALL_ACCESS, + SERVICE_WIN32_OWN_PROCESS, + SERVICE_AUTO_START, // Start automatically on system bootup. + SERVICE_ERROR_NORMAL, + filename, // Executable to register for the service. + NULL, // no load ordering group + NULL, // no tag identifier + NULL, // no dependencies + NULL, // account + NULL // password + ); + + if ( hMyService ) + break; + else + Sleep( 300 ); + } + + if ( !hMyService ) + { + Warning( "CreateService failed (%s)!\n", GetLastErrorString() ); + CloseServiceHandle( hSCManager ); + return false; + } + + + // Now setup the UI executable to run when their system starts. + HKEY hUIKey = NULL; + RegCreateKey( HKEY_LOCAL_MACHINE, HLKM_WINDOWS_RUN_KEY, &hUIKey ); + if ( !hUIKey || RegSetValueEx( hUIKey, VMPI_SERVICE_UI_VALUE_NAME, 0, REG_SZ, (unsigned char*)uiFilename, strlen( uiFilename) + 1 ) != ERROR_SUCCESS ) + { + Warning( "Can't install registry key for %s\n", uiFilename ); + return false; + } + + CloseServiceHandle( hMyService ); + return true; +} + + +void SetupStartMenuLinks( const char *pInstallerFilename ) +{ + CreateStartMenuLink( "Valve\\VMPI", "Start VMPI Service", pInstallerFilename, "-start" ); + CreateStartMenuLink( "Valve\\VMPI", "Stop VMPI Service", pInstallerFilename, "-stop" ); + CreateStartMenuLink( "Valve\\VMPI", "Uninstall VMPI", pInstallerFilename, NULL ); +} + + +void RemoveStartMenuLinks() +{ + char fullFolderName[MAX_PATH]; + if ( !SetupStartMenuSubFolderName( "Valve\\VMPI", fullFolderName, sizeof( fullFolderName ) ) ) + return; + + char errorFile[MAX_PATH]; + if ( !DeleteDirectory( fullFolderName, true, errorFile ) ) + { + Msg( "Unable to remove Start Menu items in %s.\n", fullFolderName ); + } +} + + +void CServiceInstallDlg::OnInstall() +{ + // Get the install location. + Msg( "Verifying install location.\n" ); + CString strInstallLocation; + if ( !GetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ) ) + { + Error( "Can't get install location." ); + return; + } + + if ( strchr( strInstallLocation, ':' ) == NULL ) + { + Warning( "Install location must be an absolute path (include a colon)." ); + return; + } + + // Stop the existing service. + if ( !DoUninstall( false ) ) + return; + + // Create the directory. + Msg( "Creating install directory %s.\n", strInstallLocation ); + if ( !CreateDirectory_R( strInstallLocation ) ) + { + Warning( "Unable to create directory: %s.", (const char*)strInstallLocation ); + return; + } + + // Copy the files down. + Msg( "Copying files.\n" ); + char chDir[MAX_PATH]; + GetModuleFileName( NULL, chDir, sizeof( chDir ) ); + V_StripFilename( chDir ); + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + char srcFilename[MAX_PATH], destFilename[MAX_PATH]; + V_ComposeFileName( chDir, g_pInstallFiles[i], srcFilename, sizeof( srcFilename ) ); + V_ComposeFileName( strInstallLocation, g_pInstallFiles[i], destFilename, sizeof( destFilename ) ); + + if ( !CopyFile( srcFilename, destFilename, FALSE ) ) + { + Sleep( 2000 ); + + if ( !CopyFile( srcFilename, destFilename, FALSE ) ) + { + Error( "CopyFile() failed.\nSrc: %s\nDest: %s\n%s", srcFilename, destFilename, GetLastErrorString() ); + return; + } + } + } + + // Register the service. + if ( !InstallService( m_hSCManager, strInstallLocation ) ) + return; + + // Write the new location to the registry. + Msg( "Updating registry.\n" ); + if ( RegSetValueEx( g_hVMPIKey, SERVICE_INSTALL_LOCATION_KEY, 0, REG_SZ, (BYTE*)(const char*)strInstallLocation, V_strlen( strInstallLocation ) + 1 ) != ERROR_SUCCESS ) + { + Error( "RegSetValueEx( %s, %s ) failed.", SERVICE_INSTALL_LOCATION_KEY, (const char*)strInstallLocation ); + return; + } + + // Setup start menu links. + char installerFilename[MAX_PATH]; + V_ComposeFileName( strInstallLocation, "vmpi_service_install.exe", installerFilename, sizeof( installerFilename ) ); + SetupStartMenuLinks( installerFilename ); + + // Start the new service. + Msg( "Starting new service.\n" ); + if ( DoStartExisting() ) + { + Warning( "Installed successfully!" ); + } +} + +bool CServiceInstallDlg::DoUninstall( bool bShowMessage ) +{ + // Figure out where to uninstall from. + CString strInstallLocation; + if ( !GetDlgItemText( IDC_INSTALL_LOCATION, strInstallLocation ) ) + { + Error( "Can't get install location." ); + return false; + } + + if ( _access( strInstallLocation, 0 ) == 0 && !g_bNoOutput ) + { + // Don't ask if they care if we delete all the files in that directory if the only exes in there are the install exes. + if ( AnyNonInstallFilesInDirectory( strInstallLocation ) ) + { + char str[512]; + V_snprintf( str, sizeof( str ), "Warning: this will delete all files under this directory: \n%s\nContinue?", strInstallLocation ); + if ( AfxMessageBox( str, MB_YESNO ) != IDYES ) + return false; + } + } + + // Stop both the service and the win app. + bool bDone = StopRunningApp() && StopOrDeleteService( m_hSCManager, true ); + if ( !bDone ) + return false; + + bool bSuccess = true; + RemoveRegistryKeys(); + char errorFile[MAX_PATH]; + if ( !NukeDirectory( strInstallLocation, errorFile ) ) + { + // When reinstalling, the service may not be done exiting, so give it a sec. + Sleep( 2000 ); + if ( !NukeDirectory( strInstallLocation, errorFile ) ) + { + if ( errorFile[0] ) + Msg( "NukeDirectory( %s ) failed.\nError on file: %s\n", strInstallLocation, errorFile ); + else + Msg( "NukeDirectory( %s ) failed.\n", strInstallLocation ); + + Msg( "Uninstall complete, but files are left over in %s.\n", strInstallLocation ); + + bSuccess = false; + } + } + + RemoveStartMenuLinks(); + + if ( bShowMessage && bSuccess ) + AfxMessageBox( "Uninstall successful." ); + + return true; +} + +void CServiceInstallDlg::OnUninstall() +{ + DoUninstall( true ); +} + +void CServiceInstallDlg::OnStartExisting() +{ + if ( DoStartExisting() ) + AfxMessageBox( "Started successfully." ); +} + +bool CServiceInstallDlg::DoStartExisting() +{ + StopRunningApp(); + StopOrDeleteService( m_hSCManager, false ); + + CString strInstallLocation; + if ( !GetExistingInstallationLocation( strInstallLocation ) ) + { + Error( "The VMPI service is not installed." ); + return false; + } + + if ( StartVMPIService( m_hSCManager ) ) + { + return StartVMPIServiceUI( strInstallLocation ); + } + else + { + return false; + } +} + +void CServiceInstallDlg::OnStopExisting() +{ + + // Stop the app but don't delete it. + bool bDone = StopRunningApp() && StopOrDeleteService( m_hSCManager, false ); + if ( bDone ) + { + AfxMessageBox( "Service successfully stopped." ); + } +} + +bool CServiceInstallDlg::NukeDirectory( const char *pDir, char errorFile[MAX_PATH] ) +{ + // If the directory doesn't exist anyways, then return true.. + if ( _access( pDir, 0 ) != 0 ) + return true; + + return DeleteDirectory( pDir, true, errorFile ) == 0; +} + + +void CServiceInstallDlg::VerifyInstallFiles() +{ + char chDir[MAX_PATH]; + GetModuleFileName( NULL, chDir, sizeof( chDir ) ); + V_StripFilename( chDir ); + + for ( int i=0; i < ARRAYSIZE( g_pInstallFiles ); i++ ) + { + char filename[MAX_PATH]; + V_ComposeFileName( chDir, g_pInstallFiles[i], filename, sizeof( filename ) ); + + if ( _access( filename, 0 ) != 0 ) + { + char szErrorMessage[MAX_PATH]; + + V_snprintf( szErrorMessage, sizeof( szErrorMessage ), "Required installation file missing: %s", filename ); + + AfxMessageBox( szErrorMessage ); + return; + } + } +} + |