#include #include #include #include "muisetup.h" #include "stdlib.h" #include "tchar.h" #include #include #include "lzexpand.h" #include #include #include // For SHRegisterValidateTemplate() #define SHRVT_REGISTER 0x00000001 #define DEFAULT_INSTALL_SECTION TEXT("DefaultInstall") #define DEFAULT_UNINSTALL_SECTION TEXT("DefaultUninstall") // GLOBAL variables extern TCHAR DirNames[MFL][MAX_PATH],DirNames_ie[MFL][MAX_PATH]; LPTSTR g_szSpecialFiles[] = { TEXT("hhctrlui.dll"), }; void debug(char *printout); //////////////////////////////////////////////////////////////////////////////////// // // EnumLanguages // // Enumerate the languages in the [Languages] section of MUI.INF. And check for the language // folders in the CD-ROM. // Languages is an OUT parameter, which will store the languages which has language folder // in the CD-ROM. // //////////////////////////////////////////////////////////////////////////////////// int EnumLanguages(LPTSTR Languages, BOOL bCheckDir) { DWORD dwErr; LPTSTR Language; LONG_PTR lppArgs[1]; TCHAR lpError[BUFFER_SIZE]; TCHAR lpMessage[BUFFER_SIZE]; TCHAR szInffile[MAX_PATH]; int iLanguages = 0; // // MUI.INF should be in the same directory in which the installer was // started // _tcscpy(szInffile, g_szMUIInfoFilePath); // // find out how many languages we can install // *Languages = TEXT('\0'); if (!GetPrivateProfileString( MUI_LANGUAGES_SECTION, NULL, TEXT("NOLANG"), Languages, BUFFER_SIZE, szInffile)) { // // "LOG: Unable to read MUI.INF - rc == %1" // lppArgs[0] = (LONG_PTR)GetLastError(); LogFormattedMessage(ghInstance, IDS_NO_READ_L, lppArgs); return(-1); } if (bCheckDir) { CheckLanguageDirectoryExist(Languages); } Language = Languages; // // Count the number of languages which exist in the CD-ROM, // and return that value. // while (*Language) { iLanguages++; while (*Language++) { } } return(iLanguages); } BOOL CheckLanguageDirectoryExist(LPTSTR Languages) { TCHAR szBuffer[BUFFER_SIZE]; TCHAR szSource[ MAX_PATH ]; TCHAR szTemp [ MAX_PATH ]; LPTSTR lpCur,lpBuffer; HANDLE hFile; WIN32_FIND_DATA FindFileData; memcpy(szBuffer,Languages,BUFFER_SIZE); lpCur=Languages; lpBuffer=szBuffer; while (*lpBuffer) { GetPrivateProfileString( MUI_LANGUAGES_SECTION, lpBuffer, TEXT("DEFAULT"), szSource, (sizeof(szSource)/sizeof(TCHAR)), g_szMUIInfoFilePath ); _tcscpy(szTemp,g_szMUISetupFolder); _tcscat(szTemp,szSource); _tcscat(szTemp,TEXT("\\")); _tcscat(szTemp,g_szPlatformPath); // i386 or alpha _tcscat(szTemp,TEXT("*.*")); hFile = FindFirstFile( szTemp, &FindFileData ); if (INVALID_HANDLE_VALUE != hFile ) { if (FindNextFile( hFile, &FindFileData ) && FindNextFile( hFile, &FindFileData ) ) { _tcscpy(lpCur,lpBuffer); lpCur+=(_tcslen(lpBuffer)+1); } FindClose(hFile); } while (*lpBuffer++) { } } *lpCur=TEXT('\0'); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // checkversion // // Checks the NT version and build // //////////////////////////////////////////////////////////////////////////////////// BOOL checkversion(BOOL bMatchBuildNumber) { TCHAR buffer[20]; TCHAR build[20]; OSVERSIONINFO verinfo; LANGID rcLang; TCHAR lpMessage[BUFFER_SIZE]; verinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx( &verinfo) ; if (verinfo.dwMajorVersion < 5) { debug("DBG: Need Windows NT version 5 or greater\r\n"); return (FALSE); } rcLang = (LANGID) gpfnGetSystemDefaultUILanguage(); // // need to convert decimal to hex, LANGID to chr. // _stprintf(buffer,TEXT("00000%X"), rcLang); if (_tcscmp(buffer, TEXT("00000409"))) { return(FALSE); } if (bMatchBuildNumber && FileExists(g_szMUIInfoFilePath)) { GetPrivateProfileString( TEXT("Buildnumber"), NULL, TEXT("0"), buffer, (sizeof(buffer)/ sizeof(TCHAR)), g_szMUIInfoFilePath); _stprintf(build, TEXT("%d"), verinfo.dwBuildNumber); if (!_tcscmp(buffer, TEXT("-1"))) { // // "LOG: No version check forced by MUI.INF" // LoadString(ghInstance, IDS_NO_CHECK_L, lpMessage, ARRAYSIZE(lpMessage)-1); LogMessage(lpMessage); return TRUE; } if (_tcscmp(buffer, build)) { debug(" wrong build.\r\n"); return FALSE; } } return(TRUE); } //////////////////////////////////////////////////////////////////////////////////// // // File Exists // // Returns TRUE if the file exists, FALSE if it does not. // //////////////////////////////////////////////////////////////////////////////////// BOOL FileExists(LPTSTR szFile) { HANDLE hFile; WIN32_FIND_DATA FindFileData; hFile = FindFirstFile( szFile, &FindFileData ); if (hFile == INVALID_HANDLE_VALUE) { return FALSE; } FindClose( hFile ); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // EnumDirectories // // Enumerates the directories listed in MUI.INF // //////////////////////////////////////////////////////////////////////////////////// BOOL EnumDirectories() { DWORD dwErr; LPTSTR Directories, Directory, TempDir; TCHAR lpError[BUFFER_SIZE]; TCHAR lpMessage[BUFFER_SIZE]; LONG_PTR lppArgs[3]; int Dirnumber = 0; Directories = (LPTSTR) LocalAlloc( 0, (DIRNUMBER * MAX_PATH * sizeof(TCHAR)) ); TempDir = (LPTSTR) LocalAlloc( 0, (MAX_PATH * sizeof(TCHAR)) ); if (Directories == NULL || TempDir == NULL) { ExitFromOutOfMemory(); } *Directories = TEXT('\0'); // // Copy all key names into Directories. // if (!GetPrivateProfileString( TEXT("Directories"), NULL, TEXT("DEFAULT"), Directories, (DIRNUMBER * MAX_PATH), g_szMUIInfoFilePath )) { // // "LOG: Unable to read - rc == %1" // lppArgs[0] = (LONG_PTR)GetLastError(); LogFormattedMessage(ghInstance, IDS_NO_READ_L, lppArgs); LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } Directory = Directories; // // In case we don't find anything, we go to the fallback directory // _tcscpy(DirNames[0], TEXT("FALLBACK")); while (*Directory) { if (!GetPrivateProfileString( TEXT("Directories"), Directory, TEXT("\\DEFAULT"), TempDir, MAX_PATH, g_szMUIInfoFilePath)) { // // "LOG: Unable to read - rc == %1" // lppArgs[0] = (LONG_PTR)GetLastError(); LogFormattedMessage(ghInstance, IDS_NO_READ_L, lppArgs); LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } _tcscpy(DirNames[++Dirnumber], TempDir); // Move to the beginning of next key name. while (*Directory++) { } } LocalFree( TempDir ); LocalFree( Directories ); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // EnumFileRename // // Enumerates the [File_Layout] section listed in MUI.INF // //////////////////////////////////////////////////////////////////////////////////// BOOL EnumFileRename() { DWORD dwErr; LPTSTR Directories, Directory, TempDir,lpszNext; TCHAR lpError[BUFFER_SIZE]; TCHAR lpMessage[BUFFER_SIZE],szPlatform[MAX_PATH+1],szTargetPlatform[MAX_PATH+1]; LONG_PTR lppArgs[1]; int Dirnumber = 0,nIdx=0; Directories = (LPTSTR) LocalAlloc( 0, (FILERENAMENUMBER * (MAX_PATH+1) * sizeof(TCHAR)) ); if (!Directories) { return FALSE; } TempDir = (LPTSTR) LocalAlloc( 0, ( (MAX_PATH+1) * sizeof(TCHAR)) ); if (!TempDir) { LocalFree(Directories); return FALSE; } if (gbIsAdvanceServer) { _tcscpy(szTargetPlatform,PLATFORMNAME_AS); } else if (gbIsServer) { _tcscpy(szTargetPlatform,PLATFORMNAME_SRV); } else if (gbIsWorkStation) { _tcscpy(szTargetPlatform,PLATFORMNAME_PRO); } else if ( gbIsDataCenter) { _tcscpy(szTargetPlatform,PLATFORMNAME_DTC); } else { _tcscpy(szTargetPlatform,PLATFORMNAME_PRO); } *Directories = TEXT('\0'); if (!GetPrivateProfileString( MUI_FILELAYOUT_SECTION, NULL, TEXT(""), Directories, (FILERENAMENUMBER * MAX_PATH), g_szMUIInfoFilePath )) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } Directory = Directories; // // Calculate # of entries in this section // while (*Directory) { if (!GetPrivateProfileString( MUI_FILELAYOUT_SECTION, Directory, TEXT(""), TempDir, MAX_PATH, g_szMUIInfoFilePath)) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } // // Check if platform ID field in this entry // // Source_file_name=Destination_file_name,P,S,A // lpszNext=TempDir; while ( (lpszNext=_tcschr(lpszNext,TEXT(','))) ) { lpszNext++; nIdx=0; szPlatform[0]=TEXT('\0'); while ( (*lpszNext != TEXT('\0')) && (*lpszNext != TEXT(','))) { if (*lpszNext != TEXT(' ')) { szPlatform[nIdx++]=*lpszNext; } lpszNext++; } szPlatform[nIdx]=TEXT('\0'); if (!_tcsicmp(szPlatform,szTargetPlatform)) { Dirnumber++; break; } } while (*Directory++) { } } // // Allocte Space for Rename Table // g_pFileRenameTable=(PFILERENAME_TABLE)LocalAlloc( 0, Dirnumber * sizeof(FILERENAME_TABLE) ); if (!g_pFileRenameTable) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } g_nFileRename=0; Directory = Directories; // // Create Reanme Table // while (*Directory) { if (!GetPrivateProfileString( MUI_FILELAYOUT_SECTION, Directory, TEXT(""), TempDir, MAX_PATH, g_szMUIInfoFilePath)) { LocalFree(g_pFileRenameTable); LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } // // Check if platform ID field in this entry // // Source_file_name=Destination_file_name,P,S,A // lpszNext=TempDir; while ( lpszNext =_tcschr(lpszNext,TEXT(','))) { lpszNext++; nIdx=0; szPlatform[0]=TEXT('\0'); while ( (*lpszNext != TEXT('\0')) && (*lpszNext != TEXT(','))) { if (*lpszNext != TEXT(' ')) { szPlatform[nIdx++]=*lpszNext; } lpszNext++; } szPlatform[nIdx]=TEXT('\0'); if (!_tcsicmp(szPlatform,szTargetPlatform) ) { // // Insert this entry into rename table pointed by g_pFileRenameTable // _tcscpy(g_pFileRenameTable[g_nFileRename].szSource,Directory); lpszNext=TempDir; nIdx=0; g_pFileRenameTable[g_nFileRename].szDest[0]=TEXT('\0'); while ( (*lpszNext != TEXT('\0')) && (*lpszNext != TEXT(',')) && (*lpszNext != TEXT(' ')) ) { g_pFileRenameTable[g_nFileRename].szDest[nIdx++]=*lpszNext; lpszNext++; } g_pFileRenameTable[g_nFileRename].szDest[nIdx]=TEXT('\0'); g_nFileRename++; break; } } while (*Directory++) { } } LocalFree( TempDir ); LocalFree( Directories ); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // EnumTypeNotFallback // // Enumerates the [FileType_NoFallback] section listed in MUI.INF // //////////////////////////////////////////////////////////////////////////////////// BOOL EnumTypeNotFallback() { LPTSTR Directories, Directory, TempDir,lpszNext; int Dirnumber = 0,nIdx=0; Directories = (LPTSTR) LocalAlloc( 0, (NOTFALLBACKNUMBER * (MAX_PATH+1) * sizeof(TCHAR)) ); if (!Directories) { return FALSE; } TempDir = (LPTSTR) LocalAlloc( 0, ( (MAX_PATH+1) * sizeof(TCHAR)) ); if (!TempDir) { LocalFree(Directories); return FALSE; } *Directories = TEXT('\0'); if (!GetPrivateProfileString( MUI_NOFALLBACK_SECTION, NULL, TEXT(""), Directories, (NOTFALLBACKNUMBER * MAX_PATH), g_szMUIInfoFilePath )) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } Directory = Directories; // // Calculate # of entries in this section // while (*Directory) { if (!GetPrivateProfileString( MUI_NOFALLBACK_SECTION, Directory, TEXT(""), TempDir, MAX_PATH, g_szMUIInfoFilePath)) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } Dirnumber++; while (*Directory++) { } } // // Allocte Space for // g_pNotFallBackTable=(PTYPENOTFALLBACK_TABLE)LocalAlloc( 0, Dirnumber * sizeof(TYPENOTFALLBACK_TABLE) ); if (!g_pNotFallBackTable) { LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } g_nNotFallBack=0; Directory = Directories; // // Create NoFallBack Table // while (*Directory) { if (!GetPrivateProfileString( MUI_NOFALLBACK_SECTION, Directory, TEXT(""), TempDir, MAX_PATH, g_szMUIInfoFilePath)) { LocalFree(g_pNotFallBackTable); LocalFree( TempDir ); LocalFree( Directories ); return FALSE; } // // // lpszNext=TempDir; nIdx=0; g_pNotFallBackTable[g_nNotFallBack].szSource[0]=TEXT('\0'); while ( (*lpszNext != TEXT('\0')) && (*lpszNext != TEXT(',')) && (*lpszNext != TEXT(' ')) ) { g_pNotFallBackTable[g_nNotFallBack].szSource[nIdx++]=*lpszNext; lpszNext++; } g_pNotFallBackTable[g_nNotFallBack].szSource[nIdx]=TEXT('\0'); g_nNotFallBack++; while (*Directory++) { } } LocalFree( TempDir ); LocalFree( Directories ); return TRUE; } // // Check if a given file should be renamed by searching Rename Table // BOOL IsFileBeRenamed(LPTSTR lpszSrc,LPTSTR lpszDest) { int nIdx; BOOL bResult=FALSE; if (!lpszSrc) return bResult; for (nIdx=0; nIdx < g_nFileRename; nIdx++) { LPTSTR pMUI = StrStrI(lpszSrc,g_pFileRenameTable[nIdx].szSource); if (pMUI == lpszSrc) { pMUI += lstrlen(g_pFileRenameTable[nIdx].szSource); if (!*pMUI || !lstrcmpi(pMUI, TEXT(".MUI"))) { lstrcpy(lpszDest,g_pFileRenameTable[nIdx].szDest); lstrcat(lpszDest, pMUI); bResult=TRUE; break; } } } return bResult; } // // Check if the file type of a given file belongs to the category "Do not Fallback" // BOOL IsDoNotFallBack(LPTSTR lpszFileName) { BOOL bResult = FALSE; int iLen,nIdx; iLen = _tcslen(lpszFileName); if (iLen > 4) { for (nIdx=0; nIdx < g_nNotFallBack ; nIdx++) { if (!_tcsicmp(&lpszFileName[iLen - 4],g_pNotFallBackTable[nIdx].szSource)) { bResult = TRUE; break; } } } return bResult; } //////////////////////////////////////////////////////////////////////////////////// // // Muisetup_CheckForExpandedFile // // Retreives the original filename, in case the file is compressed. // //////////////////////////////////////////////////////////////////////////////////// BOOL Muisetup_CheckForExpandedFile( PTSTR pszPathName, PTSTR pszFileName, PTSTR pszOriginalFileName, PDIAMOND_PACKET pDiamond) { TCHAR szCompressedFileName[ MAX_PATH ]; TCHAR szOut[ MAX_PATH ]; PTSTR pszTemp, pszDelimiter; BOOL bIsCompressed; int iLen=0; // Initializations bIsCompressed = FALSE; szOut[ 0 ] = szCompressedFileName[ 0 ] = TEXT('\0'); // // Get the real name // _tcscpy(szCompressedFileName, pszPathName); _tcscat(szCompressedFileName, pszFileName); if (Muisetup_IsDiamondFile( szCompressedFileName, pszOriginalFileName, MAX_PATH, pDiamond )) { return TRUE; } if (GetExpandedName(szCompressedFileName, szOut) == TRUE) { pszDelimiter = pszTemp = szOut; while (*pszTemp) { if ((*pszTemp == TEXT('\\')) || (*pszTemp == TEXT('/'))) { pszDelimiter = pszTemp; } pszTemp++; } if (*pszDelimiter == TEXT('\\') || *pszDelimiter == TEXT('/')) { pszDelimiter++; } if (_tcsicmp(pszDelimiter, pszFileName) != 0) { bIsCompressed = TRUE; _tcscpy(pszOriginalFileName, pszDelimiter); } } if (!bIsCompressed) { _tcscpy(pszOriginalFileName, pszFileName); // // If muisetup is launched through [GUIRunOnce] command line mode, // W2K uncompresses all mui files and leave the name as xxxxxx.xxx.mu_ // We should cover this situation by changing the name to xxxxxx.xxx.mui iLen = _tcslen(pszOriginalFileName); if (iLen > 4) { if (_tcsicmp(&pszOriginalFileName[iLen - 4], TEXT(".mu_")) == 0) { pszOriginalFileName[iLen-1]=TEXT('i'); } } } return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // Muisetup_CopyFile // // Copy file, and expand it if necessary. // //////////////////////////////////////////////////////////////////////////////////// BOOL Muisetup_CopyFile( PCTSTR pszCopyFrom, PTSTR pszCopyTo, PDIAMOND_PACKET pDiamond, PTSTR pOriginalName) { OFSTRUCT ofs; INT hfFrom = -1, hfTo = -1; BOOL bRet = FALSE; // // Check if diamond can handle it // bRet = Muisetup_CopyDiamondFile( pDiamond, pszCopyTo ); if (bRet) { // // Diamond copy won't rename file for us // if (pOriginalName) { WCHAR wszPath[MAX_PATH]; // // Diamond is ANSI // if (MultiByteToWideChar(1252, 0, pDiamond->szDestFilePath, -1, wszPath, ARRAYSIZE(wszPath))) { StrCat(wszPath, pOriginalName); MoveFileEx(wszPath,pszCopyTo,MOVEFILE_REPLACE_EXISTING); } } return bRet; } hfFrom = LZOpenFile( (PTSTR) pszCopyFrom, &ofs, OF_READ ); if (hfFrom < 0) { goto CopyFileRetry; } hfTo = LZOpenFile( (PTSTR) pszCopyTo, &ofs, OF_CREATE | OF_WRITE); if (hfTo < 0) { goto CopyFileRetry; } if (LZCopy(hfFrom, hfTo) < 0) { goto CopyFileRetry; } LZClose(hfFrom); LZClose(hfTo); return TRUE; CopyFileRetry: // // We may end up in a case where either the user uses directories with // path names > 128 characters(this will fail the LZ API's) or the LZ's // just fail. We just revert back to CopyFile and let the user deal // with that. // if(hfFrom >= 0) { LZClose(hfFrom); } if(hfTo >= 0) { LZClose(hfTo); } return CopyFile(pszCopyFrom, pszCopyTo, FALSE); } //////////////////////////////////////////////////////////////////////////////////// // // InstallComponentsMUIFiles // // Parameters: // pszLangSourceDir The sub-directory name for a specific lanuage in the MUI CD-ROM. // E.g. "jpn.MUI" // pszLanguage The LCID for the specific language. E.g. "0404". // isInstall TRUE if you are going to install the MUI files for the component. FALSE // if you are going to uninstall. // [OUT] pbCanceled TRUE if the operation is canceled. // [OUT] pbError TURE if error happens. // // Return: // TRUE if success. Otherwise FALSE. // // Note: // For the language resources stored in pszLangSourceDir, this function will enumerate // the compoents listed in the [Components] // (the real section is put in MUI_COMPONENTS_SECTION) section, and execute the INF file // listed in every entry in // the [Components] section. // //////////////////////////////////////////////////////////////////////////////////// BOOL InstallComponentsMUIFiles(PTSTR pszLangSourceDir, PTSTR pszLanguage, BOOL isInstall) { BOOL result = TRUE; TCHAR szComponentName[BUFFER_SIZE]; TCHAR CompDir[BUFFER_SIZE]; TCHAR CompINFFile[BUFFER_SIZE]; TCHAR CompInstallSection[BUFFER_SIZE]; TCHAR CompUninstallSection[BUFFER_SIZE]; TCHAR szCompInfFullPath[MAX_PATH]; LONG_PTR lppArgs[2]; INFCONTEXT InfContext; TCHAR szBuffer[BUFFER_SIZE]; HINF hInf = SetupOpenInfFile(g_szMUIInfoFilePath, NULL, INF_STYLE_WIN4, NULL); if (hInf == INVALID_HANDLE_VALUE) { _stprintf(szBuffer, TEXT("%d"), GetLastError()); lppArgs[0] = (LONG_PTR)szBuffer; LogFormattedMessage(ghInstance, IDS_NO_READ_L, lppArgs); return (FALSE); } // // Get the first comopnent to be installed. // if (SetupFindFirstLine(hInf, MUI_COMPONENTS_SECTION, NULL, &InfContext)) { do { if (!SetupGetStringField(&InfContext, 0, szComponentName, sizeof(szComponentName), NULL)) { lppArgs[0]=(LONG_PTR)szComponentName; LogFormattedMessage(ghInstance, IDS_COMP_MISSING_NAME_L, lppArgs); continue; } if (!SetupGetStringField(&InfContext, 1, CompDir, sizeof(CompDir), NULL)) { // // "LOG: MUI files for component %1 was not installed because of missing component direcotry.\n" // lppArgs[0]=(LONG_PTR)szComponentName; LogFormattedMessage(ghInstance, IDS_COMP_MISSING_DIR_L, lppArgs); continue; } if (!SetupGetStringField(&InfContext, 2, CompINFFile, sizeof(CompINFFile), NULL)) { // // "LOG: MUI files for component %1 were not installed because of missing component INF filename.\n" // lppArgs[0]=(LONG_PTR)szComponentName; LogFormattedMessage(ghInstance, IDS_COMP_MISSING_INF_L, lppArgs); continue; } if (!SetupGetStringField(&InfContext, 3, CompInstallSection, sizeof(CompInstallSection), NULL)) { _tcscpy(CompInstallSection, DEFAULT_INSTALL_SECTION); } if (!SetupGetStringField(&InfContext, 4, CompUninstallSection, sizeof(CompUninstallSection), NULL)) { _tcscpy(CompUninstallSection, DEFAULT_UNINSTALL_SECTION); } // // Establish the correct path for component INF file. // if (isInstall) { // // For installation, we execute the INFs in the language directory of the CD-ROM (e.g. // g:\jpn.mui\i386\ie5\ie5ui.inf // _stprintf(szCompInfFullPath, TEXT("%s%s\\%s%s\\%s"), g_szMUISetupFolder, pszLangSourceDir, g_szPlatformPath, CompDir, CompINFFile); if (!ExecuteComponentINF(NULL, szComponentName, szCompInfFullPath, CompInstallSection, TRUE)) { if (DoMessageBox(NULL, IDS_CANCEL_INSTALLATION, IDS_MAIN_TITLE, MB_YESNO) == IDNO) { result = FALSE; break; } } } else { // // For uninstallation, we execute the INFs in the \winnt\mui\fallback directory to remove component files. // _stprintf(szCompInfFullPath, TEXT("%s%s\\%s\\%s"), g_szWinDir, FALLBACKDIR, pszLanguage, CompINFFile) ; if (!ExecuteComponentINF(NULL, szComponentName, szCompInfFullPath, CompUninstallSection, FALSE) && result) { result = FALSE; } } // // Install the next component. // } while (SetupFindNextLine(&InfContext, &InfContext)); } SetupCloseInfFile(hInf); return (result); } //////////////////////////////////////////////////////////////////////////////////// // // CopyFiles // // Copies the specified files to the appropriate directories // // Parameters: // [in] languages: contain the hex string for the languages to be installed. There could be more than one language. // [out] lpbCopyCancelled: if the copy operation has been cancelled. // // Notes: // This function first look at the [Languages] section in the INF file to find out the // source directory (in the CD-ROM) for the language to be installed. // From that directory, do: // 1. install the MUI files for the components listed in the [Components] section, // 2. Enumarate every file in that direcotry to: // Check if the same file exists in directories in DirNames. If yes, this means we have to copy // the mui file to that particular direcotry. Otherwise, copy the file to the FALLBACK directory. // //////////////////////////////////////////////////////////////////////////////////// BOOL CopyFiles(HWND hWnd, LPTSTR Languages) { LPTSTR Language; HANDLE hFile; HWND hStatic; TCHAR lpStatus[ BUFFER_SIZE ]; TCHAR lpLangText[ BUFFER_SIZE ]; TCHAR szSource[ MAX_PATH ] = {0}; // The source directory for a particular language TCHAR szTarget[ MAX_PATH ]; TCHAR szTemp[ MAX_PATH ]; TCHAR szOriginalFileName[ MAX_PATH ]; TCHAR szFileNameBeforeRenamed[ MAX_PATH], szFileNameCopied[MAX_PATH]; TCHAR szFileRenamed[MAX_PATH]; DIAMOND_PACKET diamond; BOOL CreateFailure = FALSE; BOOL CopyOK=TRUE; BOOL bFileWithNoMuiExt=FALSE; BOOL FileCopied = FALSE; BOOL bSpecialDirectory=FALSE; BOOL bRename=FALSE; WIN32_FIND_DATA FindFileData; int FoundMore = 1; int Dirnum = 0; int iLen; int NotDeleted = 0; int i; TCHAR dir[_MAX_DIR]; TCHAR fname[_MAX_FNAME]; TCHAR ext[_MAX_EXT]; LONG_PTR lppArgs[1]; MSG msg; // // we need to try to copy for each language to be installed the file // hStatic = GetDlgItem(ghProgDialog, IDC_STATUS); Language = Languages; while (*Language) { // // Find the directory in which the sourcefile for given language should be // GetPrivateProfileString( MUI_LANGUAGES_SECTION, Language, TEXT("DEFAULT"), szSource, (sizeof(szSource)/sizeof(TCHAR)), g_szMUIInfoFilePath ); // // Install Fusion MUI assemblies // if (gpfnSxsInstallW) { TCHAR pszLogFile[BUFFER_SIZE]; if ( !DeleteSideBySideMUIAssemblyIfExisted(Language, pszLogFile)) { TCHAR errInfo[BUFFER_SIZE]; swprintf(errInfo, TEXT("Uninstall existing assemblies based on %s before new installation failed\n"), pszLogFile); OutputDebugString(errInfo); } if (GetFileAttributes(pszLogFile) != 0xFFFFFFFF) { DeleteFile(pszLogFile); // no use anyway } TCHAR szFusionAssemblyPath[BUFFER_SIZE]; PathCombine(szFusionAssemblyPath, g_szMUISetupFolder, szSource); PathAppend(szFusionAssemblyPath, g_szPlatformPath); PathAppend(szFusionAssemblyPath, TEXT("ASMS")); SXS_INSTALLW SxsInstallInfo = {sizeof(SxsInstallInfo)}; SXS_INSTALL_REFERENCEW Reference = {sizeof(Reference)}; Reference.guidScheme = SXS_INSTALL_REFERENCE_SCHEME_OPAQUESTRING; Reference.lpIdentifier = MUISETUP_ASSEMBLY_INSTALLATION_REFERENCE_IDENTIFIER; SxsInstallInfo.dwFlags = SXS_INSTALL_FLAG_REPLACE_EXISTING | SXS_INSTALL_FLAG_REFERENCE_VALID | SXS_INSTALL_FLAG_CODEBASE_URL_VALID | SXS_INSTALL_FLAG_LOG_FILE_NAME_VALID | SXS_INSTALL_ASSEMBLY_FLAG_FROM_DIRECTORY_RECURSIVE; SxsInstallInfo.lpReference = &Reference; SxsInstallInfo.lpLogFileName = pszLogFile; SxsInstallInfo.lpManifestPath = szFusionAssemblyPath; SxsInstallInfo.lpCodebaseURL = SxsInstallInfo.lpManifestPath; if ( !gpfnSxsInstallW(&SxsInstallInfo)) { TCHAR errInfo[BUFFER_SIZE]; swprintf(errInfo, TEXT("Assembly Installation of %s failed. Please refer Eventlog for more information"), szFusionAssemblyPath); OutputDebugString(errInfo); } } GetLanguageGroupDisplayName((LANGID)_tcstol(Language, NULL, 16), lpLangText, ARRAYSIZE(lpLangText)-1); lppArgs[0] = (LONG_PTR)lpLangText; // // Try installing component satellite DLLs // FormatStringFromResource(lpStatus, sizeof(lpStatus)/sizeof(TCHAR), ghInstance, IDS_INSTALLING_COMP_MUI, lppArgs); SetWindowText(hStatic, lpStatus); if (!InstallComponentsMUIFiles(szSource, NULL, TRUE)) { #ifndef IGNORE_COPY_ERRORS DeleteFiles(Languages,&NotDeleted); return FALSE; #endif } // // Output what is being installed on the progress dialog box // LoadString(ghInstance, IDS_INSTALLING, lpStatus, ARRAYSIZE(lpStatus)-1); FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, lpStatus, 0, 0, lpStatus, ARRAYSIZE(lpStatus)-1, (va_list *)lppArgs); SetWindowText(hStatic, lpStatus); // // find first file in language subdirectory // _tcscpy(szTemp,szSource); // szSource = g_szMUISetupFolder\szSource\tchPlatfromPath // e.g. szSource = "g_szMUISetupFolder\JPN.MUI\i386\" _tcscpy(szSource,g_szMUISetupFolder); _tcscat(szSource,szTemp); _tcscat(szSource, TEXT("\\")); _tcscat(szSource, g_szPlatformPath); // i386 or alpha // szTemp = szSource + "*.*" // e.g. szTemp = "g_szMUISetupFolder\JPN.MUI\i386\*.*" _tcscpy(szTemp,szSource); _tcscat(szTemp,TEXT("*.*")); FoundMore = 1; // reset foundmore for next language. hFile = FindFirstFile( szTemp, &FindFileData ); if (INVALID_HANDLE_VALUE == hFile) return FALSE; _tcscpy(szTemp, TEXT("")); while (FoundMore) { CreateFailure=FALSE; FileCopied=FALSE; if (!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { // // Reset diamond stuff for the new file // Muisetup_DiamondReset(&diamond); // // Check if it's a compressed file or not // Muisetup_CheckForExpandedFile( szSource, FindFileData.cFileName, szOriginalFileName, &diamond ); if (IsFileBeRenamed(szOriginalFileName,szFileRenamed)) { _tcscpy(szFileNameBeforeRenamed,szOriginalFileName); _tcscpy(szOriginalFileName,szFileRenamed); bRename=TRUE; } else { bRename=FALSE; } // e.g. szTemp = "shell32.dll" _tcscpy(szTemp, szOriginalFileName); ////////////// FileCopied=FALSE; for (Dirnum=1; (_tcslen(DirNames[Dirnum])>0); Dirnum++ ) { // // see where this file has to go // pfnGetWindowsDir( szTarget, MAX_PATH); // e.g. szTarget = "c:\winnt\system32\wbem" _tcscat(szTarget, DirNames[Dirnum]); if (_tcscmp(DirNames[Dirnum], TEXT("\\"))) { _tcscat(szTarget, TEXT("\\")); } bFileWithNoMuiExt = FALSE; _tcscpy(szTemp, szOriginalFileName); //remove .mui if it's .mui //////// iLen = _tcslen(szTemp); if (iLen > 4) { if (_tcsicmp(&szTemp[iLen - 4], TEXT(".mui")) == 0) { *(szTemp + iLen - 4) = 0; } else { bFileWithNoMuiExt = TRUE; } } _tcscat(szTarget, szTemp); // // Check the file with the same name (with the .mui extension) exist in the // system directory. If yes, this means that we need to copy the mui file. // if (FileExists(szTarget)) { // // need to copy this file to the directory // FileCopied = TRUE; // // copy filename in szTemp and directory in szTarget // _tsplitpath( szTarget, szTemp, dir, fname, ext ); _tcscpy(szTarget, szTemp); // drive name _tcscat(szTarget, dir); // directory name // //now szTarget = Directory, szTemp = filename // _tcscat(szTarget, MUIDIR); // append MUI to directory if (!MakeDir(szTarget)) // if the MUI dir doesn't exist yet, create it. { MakeDirFailed(szTarget); CreateFailure = TRUE; } _tcscat(szTarget, TEXT("\\")); _tcscat(szTarget, Language); // add Language Identifier (from MUI.INF, e.g., 0407) if (!FileExists(szTarget)) // if the directory doesn't exist yet { if (!MakeDir(szTarget)) // if the LANGID dir doesn't exist yet, create it. { MakeDirFailed(szTarget); CreateFailure=TRUE; } } _tcscat(szTarget, TEXT("\\")); // append \ / if (bRename) { _tcscpy(szFileNameCopied,szTarget); _tcscat(szFileNameCopied,szFileNameBeforeRenamed); } _tcscat(szTarget, szOriginalFileName); // append filename _tcscpy(szTemp, szSource); _tcscat(szTemp, FindFileData.cFileName); if (!CreateFailure) { if (!Muisetup_CopyFile(szTemp, szTarget, &diamond, bRename? szFileNameBeforeRenamed:NULL)) { CopyFileFailed(szTarget,0); CreateFailure = TRUE; CopyOK = FALSE; } else { SendMessage(ghProgress, PBM_DELTAPOS, (WPARAM)(1), 0); // // Diamond decompression doesn't rename correctly // /* if (bRename) { MoveFileEx(szFileNameCopied,szTarget,MOVEFILE_REPLACE_EXISTING); } */ } } } // if fileexists } // of for // // the file was not found in any of the known MUI targets -> fallback. // Simple hack for FAXUI.DLL to be copied to the fallback directory as well. // bSpecialDirectory=FALSE; for (i = 0; i < ARRAYSIZE(g_szSpecialFiles); i++) { if (_tcsicmp(szOriginalFileName, g_szSpecialFiles[i]) == 0) { bSpecialDirectory=TRUE; } } if ( ( (FileCopied != TRUE) && (!IsDoNotFallBack(szOriginalFileName))) || (_tcsicmp(szOriginalFileName, TEXT("faxui.dll.mui")) == 0) ) { pfnGetWindowsDir(szTarget, MAX_PATH); //%windir% // _tcscat(szTarget, TEXT("\\")); // // If the file couldn't be found in any of the above, and it's extension // doesn't contain .mui, then copy it to %windir%\system32 // szTemp holds the filename. // if (bSpecialDirectory) { // e.g. szTarget = "c:\winnt\system32\"; _tcscat(szTarget, TEXT("system32\\")); } // e.g. szTarget = "c:\winnt\system32\MUI" (when bSpecialDirectory = TRUE) or "c:\winnt\MUI" _tcscat(szTarget, MUIDIR); // \MUI // if (!MakeDir(szTarget)) // if the MUI dir doesn't exist yet, create it. { MakeDirFailed(szTarget); CreateFailure = TRUE; } if (!bSpecialDirectory) { // e.g. szTarget = "C:\winnt\MUI\FALLBACK" _tcscat(szTarget, TEXT("\\")); _tcscat(szTarget, TEXT("FALLBACK")); // FALLBACK if (!MakeDir(szTarget)) // if the MUI dir doesn't exist yet, create it. { MakeDirFailed(szTarget); CreateFailure = TRUE; } } _tcscat(szTarget, TEXT("\\")); // \ // // e.g. szTarget = "c:\winnt\system32\MUI\0411" (when bSpecialDirectory = TRUE) or "c:\winnt\MUI\FALLBACK\0411" _tcscat(szTarget, Language); // add Language Identifier (from MUI.INF, e.g., 0407) if (!MakeDir(szTarget)) // if the MUI dir doesn't exist yet, create it. { MakeDirFailed(szTarget); CreateFailure = TRUE; } _tcscat(szTarget, TEXT("\\")); // \ // _tcscat(szTarget, szOriginalFileName); // filename _tcscpy(szTemp, szSource); _tcscat(szTemp, FindFileData.cFileName); if (!CreateFailure) { if (!Muisetup_CopyFile(szTemp, szTarget, &diamond, bRename? szFileNameBeforeRenamed:NULL)) { CopyFileFailed(szTarget,0); CopyOK = FALSE; } else { SendMessage(ghProgress, PBM_DELTAPOS, (WPARAM)(1), 0); } } if (CreateFailure == TRUE) { CopyOK=FALSE; } } // fallback case } // of file not dir FoundMore = FindNextFile( hFile, &FindFileData ); // // Since this is a lengthy operation, we should // peek and dispatch window messages here so // that MUISetup dialog could repaint itself. // while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) { return (FALSE); } TranslateMessage(&msg); DispatchMessage(&msg); } } // of while FindClose(hFile); lppArgs[0] = (LONG_PTR)Language; LogFormattedMessage(NULL, IDS_LANG_INSTALLED, lppArgs); while (*Language++) // go to the next language and repeat { } } // of while (*Language) #ifndef IGNORE_COPY_ERRORS if (!CopyOK) { if (DoMessageBox(NULL, IDS_CANCEL_INSTALLATION, IDS_MAIN_TITLE, MB_YESNO) == IDNO) { DeleteFiles(Languages,&NotDeleted); } else { CopyOK = TRUE; } } #endif return CopyOK; } //////////////////////////////////////////////////////////////////////////////////// // // Copy or remove muisetup related files // Help file : %windir%\help // Other files : %windir%\mui // //////////////////////////////////////////////////////////////////////////////////// BOOL CopyRemoveMuiItself(BOOL bInstall) { // // MUISETUP files need to be copied from MUI CD // TCHAR *TargetFiles[] = { TEXT("muisetup.exe"), TEXT("mui.inf"), TEXT("eula.txt"), TEXT("readme.txt"), TEXT("relnotes.txt") }; TCHAR szTargetPath[MAX_PATH+1], szTargetFile[MAX_PATH+1]; TCHAR szSrcFile[MAX_PATH+1]; TCHAR szHelpFile[MAX_PATH+1]; BOOL bRet = FALSE; int i; PathCombine(szTargetPath, g_szWinDir, MUIDIR); if (MakeDir(szTargetPath)) { // // Copy over MUISETUP related files // for (i=0; i 0) return bResult; SystemUILangId=(LCID) gSystemUILangId; for ( nIdx=0; nIdx0); Dirnum++ ) { // szTarget = "c:\winnt" _tcscpy(szTarget, g_szWinDir); // e.g. szTarget = "c:\winnt\system32\Wbem" _tcscat(szTarget, DirNames[Dirnum]); if (_tcscmp(DirNames[Dirnum], TEXT("\\"))) { // e.g. szTarget = "c:\winnt\system32\Wbem\" _tcscat(szTarget, TEXT("\\")); } // e.g. szTarget = "c:\winnt\system32\Wbem\MUI" _tcscat(szTarget, MUIDIR); // e.g. szTarget = "c:\winnt\system32\Wbem\MUI\0404" _tcscat(szTarget, TEXT("\\")); _tcscat(szTarget, Language); DoRemoveFiles(szTarget, lpNotDeleted); } // Uninstall Component MUI Files. // Note that we should do this before removing all files under FALLBACK directory, // since we store compoent INF files under the FALLBACK directory. InstallComponentsMUIFiles(NULL, Language, FALSE); // // Remove all files under FALLBACK directory. // // E.g. szTarget = "c:\winnt\mui" _tcscpy(szTarget, g_szWinDir); _tcscat(szTarget, TEXT("\\")); _tcscat(szTarget, MUIDIR); _tcscpy(szMuiDir, szTarget); // E.g. szTarget = "c:\winnt\mui\FALLBACK" _tcscat(szTarget, TEXT("\\")); _tcscat(szTarget, TEXT("FALLBACK")); _tcscpy(szFallbackDir, szTarget); _tcscat(szTarget, TEXT("\\")); // E.g. szTarget = "c:\winnt\mui\FALLBACK\0404" _tcscat(szTarget, Language); DoRemoveFiles(szTarget, lpNotDeleted); // // Remove files listed in g_szSpecialFiles // for (i = 0; i < ARRAYSIZE(g_szSpecialFiles); i++) { // e.g. szTarget = "c:\winnt\system32\mui\0411\hhctrlui.dll" wsprintf(szTarget, L"%s\\system32\\%s\\%s\\%s", g_szWinDir, MUIDIR, Language, g_szSpecialFiles[i]); if (!MUI_DeleteFile(szTarget)) { (*lpNotDeleted)++; } } /* // e.g. szTarget = "c:\winnt\system32\mui\0411" wsprintf(szTarget, L"%s\\system32\\%s\\%s", g_szWinDir, MUIDIR, Language); DoRemoveFiles(szTarget, lpNotDeleted); */ lppArgs[0] = (LONG_PTR)Language; LogFormattedMessage(NULL, IDS_LANG_UNINSTALLED, lppArgs); while (*Language++) // go to the next language and repeat { } } // of while (*Language) // // Removes Fallback directory if all languages have been uninstalled. // if (!RemoveDirectory(szFallbackDir)) { MoveFileEx(szFallbackDir, NULL, MOVEFILE_DELAY_UNTIL_REBOOT); } // // Removes MUI directory if all languages have been uninstalled and Fallback // directory has been removed. // if (IsAllLanguageRemoved(Langchk)) { CopyRemoveMuiItself(FALSE); } if (!RemoveDirectory(szMuiDir)) { MoveFileEx(szMuiDir, NULL, MOVEFILE_DELAY_UNTIL_REBOOT); } return TRUE; } BOOL CompareMuisetupVersion(LPTSTR pszSrc,LPTSTR pszTarget) { BOOL bResult=TRUE; ULONG ulHandle,ulHandle1,ulBytes,ulBytes1; PVOID pvoidBuffer=NULL,pvoidBuffer1=NULL; VS_FIXEDFILEINFO *lpvsInfo,*lpvsInfo1; UINT unLen; if ( (!pszSrc) || (!pszTarget)) { bResult = FALSE; goto endcompare; } ulBytes = GetFileVersionInfoSize( pszSrc, &ulHandle ); if ( ulBytes == 0 ) goto endcompare; ulBytes1 = GetFileVersionInfoSize( pszTarget,&ulHandle1 ); if ( ulBytes1 == 0 ) goto endcompare; pvoidBuffer=LocalAlloc(LMEM_FIXED,ulBytes+1); if (!pvoidBuffer) goto endcompare; pvoidBuffer1=LocalAlloc(LMEM_FIXED,ulBytes1+1); if (!pvoidBuffer1) goto endcompare; if ( !GetFileVersionInfo( pszSrc, ulHandle, ulBytes, pvoidBuffer ) ) goto endcompare; if ( !GetFileVersionInfo( pszTarget, ulHandle1, ulBytes1, pvoidBuffer1 ) ) goto endcompare; // Get fixed info block if ( !VerQueryValue( pvoidBuffer,_T("\\"),(LPVOID *)&lpvsInfo,&unLen ) ) goto endcompare; if ( !VerQueryValue( pvoidBuffer1,_T("\\"),(LPVOID *)&lpvsInfo1,&unLen ) ) goto endcompare; bResult = FALSE; // // We do nothing if major release version is different // // I.E We won't copy a new muisetup.exe over a old one if major release version of them are different // if ( (lpvsInfo->dwFileVersionMS == lpvsInfo1->dwFileVersionMS) && (lpvsInfo->dwFileVersionLS < lpvsInfo1->dwFileVersionLS)) { bResult = TRUE; } endcompare: if(pvoidBuffer) LocalFree(pvoidBuffer); if(pvoidBuffer1) LocalFree(pvoidBuffer1); return bResult; } //////////////////////////////////////////////////////////////////////////////////// // // MZStrLen // // Calculate the length of MULTI_SZ string // // the length is in bytes and includes extra terminal NULL, so the length >= 1 (TCHAR) // //////////////////////////////////////////////////////////////////////////////////// UINT MZStrLen(LPTSTR lpszStr) { UINT i=0; while (lpszStr && *lpszStr) { i += ((lstrlen(lpszStr)+1) * sizeof(TCHAR)); lpszStr += (lstrlen(lpszStr)+1); } // // extra NULL // i += sizeof(TCHAR); return i; } //////////////////////////////////////////////////////////////////////////////////// // // SetFontLinkValue // // Set necessary font link value into registry // // lpszLinkInfo = "Target","Link1","Link2",.... // //////////////////////////////////////////////////////////////////////////////////// BOOL SetFontLinkValue (LPTSTR lpszLinkInfo,BOOL *lpbFontLinkRegistryTouched) { const TCHAR szDeli[] = TEXT("\\\\"); TCHAR szStrBuf[FONTLINK_BUF_SIZE]; TCHAR szRegDataStr[FONTLINK_BUF_SIZE]; LPTSTR lpszDstStr,lpszSrcStr; LPTSTR lpszFontName; LPTSTR lpszTok; DWORD dwType; DWORD cbData; HKEY hKey; LONG rc; BOOL bRet = FALSE; lpszSrcStr = szStrBuf; lpszTok = _tcstok(lpszLinkInfo,szDeli); while (lpszTok) { lstrcpy(lpszSrcStr,lpszTok); lpszSrcStr += (lstrlen(lpszTok) + 1); lpszTok = _tcstok(NULL,szDeli); } *lpszSrcStr = TEXT('\0'); // // first token is base font name // lpszSrcStr = lpszFontName = szStrBuf; if (! *lpszFontName) { // // there is no link info needs to be processed // bRet = FALSE; goto Exit1; } // // point to first linked font // lpszSrcStr += (lstrlen(lpszSrcStr) + 1); if (! *lpszSrcStr) { // // no linked font // bRet = FALSE; goto Exit1; } rc = RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink"), 0L, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey, NULL); if (rc != ERROR_SUCCESS) { bRet = FALSE; goto Exit1; } cbData = sizeof(szRegDataStr); rc = RegQueryValueEx(hKey, lpszFontName, NULL, &dwType, (LPBYTE) szRegDataStr, &cbData); if (rc != ERROR_SUCCESS) { // // case 1, this font's font link hasn't been set yet, or something wrong in old value // lpszDstStr = lpszSrcStr; } else { // // case 2, this font's font link list has been there // // we need check if new font is defined in font list or not. // while (*lpszSrcStr) { lpszDstStr = szRegDataStr; while (*lpszDstStr) { if (lstrcmpi(lpszSrcStr,lpszDstStr) == 0) { break; } lpszDstStr += (lstrlen(lpszDstStr) + 1); } if (! *lpszDstStr) { // // the font is not in original linke font list then // // append to end of list // // // make sure this is a safe copy // if (lpszDstStr+(lstrlen(lpszSrcStr)+2) < szRegDataStr+FONTLINK_BUF_SIZE) { lstrcpy(lpszDstStr,lpszSrcStr); lpszDstStr += (lstrlen(lpszDstStr) + 1); *lpszDstStr = TEXT('\0'); } } lpszSrcStr += (lstrlen(lpszSrcStr) + 1); } lpszDstStr = szRegDataStr; } // // in this step,lpszDstStr is new font link list // rc = RegSetValueEx( hKey, lpszFontName, 0L, REG_MULTI_SZ, (LPBYTE)lpszDstStr, MZStrLen(lpszDstStr)); if (rc != ERROR_SUCCESS) { goto Exit2; } bRet = TRUE; *lpbFontLinkRegistryTouched = TRUE; Exit2: RegCloseKey(hKey); Exit1: return bRet; } //////////////////////////////////////////////////////////////////////////////////// // // MofCompileLanguages // // Call the WBEM API to mofcompile the MFL's for each language // //////////////////////////////////////////////////////////////////////////////////// BOOL MofCompileLanguages(LPTSTR Languages) { pfnMUI_InstallMFLFiles pfnMUIInstall = NULL; TCHAR buffer[5]; LPTSTR Language = Languages; TCHAR lpMessage[BUFFER_SIZE]; LONG_PTR lppArgs[1]; HMODULE hWbemUpgradeDll = NULL; TCHAR szDllPath[MAX_PATH]; // // Load the WBEM upgrade DLL from system wbem folder // if (GetSystemDirectory(szDllPath, ARRAYSIZE(szDllPath)) && PathAppend(szDllPath, TEXT("wbem\\wbemupgd.dll"))) { hWbemUpgradeDll = LoadLibrary(szDllPath); } // // Fall back to system default path if previous loading fails // if (!hWbemUpgradeDll) { hWbemUpgradeDll = LoadLibrary(TEXT("WBEMUPGD.DLL")); if (!hWbemUpgradeDll) { return FALSE; } } // // Hook function pointer // pfnMUIInstall = (pfnMUI_InstallMFLFiles)GetProcAddress(hWbemUpgradeDll, "MUI_InstallMFLFiles"); if (pfnMUIInstall == NULL) { FreeLibrary(hWbemUpgradeDll); return FALSE; } // process each language while (*Language) { _tcscpy(buffer, Language); if (!pfnMUIInstall(buffer)) { // log error for this language LoadString(ghInstance, IDS_MOFCOMPILE_LANG_L, lpMessage, ARRAYSIZE(lpMessage)-1); lppArgs[0] = (LONG_PTR)buffer; FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, lpMessage, 0, 0, lpMessage, ARRAYSIZE(lpMessage)-1, (va_list *)lppArgs); LogMessage(lpMessage); } while (*Language++) // go to the next language and repeat { } } // of while (*Language) FreeLibrary(hWbemUpgradeDll); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // UpdateRegistry // // Update the Registry to account for languages that have been installed // //////////////////////////////////////////////////////////////////////////////////// BOOL UpdateRegistry(LPTSTR Languages,BOOL *lpbFontLinkRegistryTouched) { TCHAR szRegPath[MAX_PATH]; TCHAR szValue[] = TEXT("1"); LPTSTR Language; DWORD dwErr; HKEY hkey; DWORD dwDisp; _tcscpy(szRegPath, TEXT("SYSTEM\\CurrentControlSet\\Control\\Nls\\MUILanguages")); dwErr = RegCreateKeyEx( HKEY_LOCAL_MACHINE, // handle of an open key szRegPath, // address of subkey name 0, // reserved TEXT("REG_SZ"), // address of class string REG_OPTION_NON_VOLATILE , // special options flag KEY_ALL_ACCESS, // desired security access NULL, &hkey, // address of szRegPath for opened handle &dwDisp // address of disposition value szRegPath ); if (dwErr != ERROR_SUCCESS) { return FALSE; } Language = Languages; lstrcpy(szRegPath, TEXT("0409")); dwErr = RegSetValueEx( hkey, szRegPath, 0, REG_SZ, (const BYTE *)szValue, (lstrlen(szValue) + 1) * sizeof(TCHAR)); while (*Language) { TCHAR szFontLinkVal[FONTLINK_BUF_SIZE]; DWORD dwNum; lstrcpy(szRegPath, Language); dwErr = RegSetValueEx( hkey, szRegPath, 0, REG_SZ, (const BYTE *)szValue, (lstrlen(szValue) + 1)*sizeof(TCHAR)); if (dwErr != ERROR_SUCCESS) { RegCloseKey(hkey); return FALSE; } dwNum = GetPrivateProfileString(TEXT("FontLink"), szRegPath, TEXT(""), szFontLinkVal, (sizeof(szFontLinkVal)/sizeof(TCHAR)), g_szMUIInfoFilePath); if (dwNum) { SetFontLinkValue(szFontLinkVal,lpbFontLinkRegistryTouched); } while (*Language++); // go to the next language and repeat } // of while (*Language) RegCloseKey(hkey); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // UpdateFontLinkRegistry // // Update the Font Link Registry to account for languages that have been installed // //////////////////////////////////////////////////////////////////////////////////// BOOL UpdateRegistry_FontLink(LPTSTR Languages,BOOL *lpbFontLinkRegistryTouched) { TCHAR buffer[400]; LPTSTR Language; DWORD dwErr; DWORD dwDisp; Language = Languages; while (*Language) { TCHAR szFontLinkVal[FONTLINK_BUF_SIZE]; DWORD dwNum; _tcscpy(buffer, Language); dwNum = GetPrivateProfileString(TEXT("FontLink"), buffer, TEXT(""), szFontLinkVal, (sizeof(szFontLinkVal)/sizeof(TCHAR)), g_szMUIInfoFilePath); if (dwNum) { SetFontLinkValue(szFontLinkVal,lpbFontLinkRegistryTouched); } while (*Language++) // go to the next language and repeat { } } // of while (*Language) return TRUE; } void debug(char *printout) { #ifdef _DEBUG fprintf(stderr, "%s", printout); #endif } //////////////////////////////////////////////////////////////////////////////////// // // MakeDir // // Create the directory if it does not already exist // //////////////////////////////////////////////////////////////////////////////////// BOOL MakeDir(LPTSTR szTarget) { TCHAR lpMessage[BUFFER_SIZE]; LONG_PTR lppArgs[1]; if (!FileExists(szTarget)) // if the directory doesn't exist yet { if (!CreateDirectory( szTarget, NULL)) // create it { // // "LOG: Error creating directory %1" // LoadString(ghInstance, IDS_CREATEDIR_L, lpMessage, ARRAYSIZE(lpMessage)-1); lppArgs[0]=(LONG_PTR)szTarget; FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, lpMessage, 0, 0, lpMessage, ARRAYSIZE(lpMessage)-1, (va_list *)lppArgs); LogMessage(lpMessage); FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0, lpMessage, ARRAYSIZE(lpMessage)-1, NULL); LogMessage(lpMessage); return FALSE; } } return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // MakeDirFailed // // Write message to log file that MakeDir failed. // //////////////////////////////////////////////////////////////////////////////////// BOOL MakeDirFailed(LPTSTR lpDirectory) { TCHAR lpMessage[BUFFER_SIZE]; LONG_PTR lppArgs[1]; // // "LOG: MakeDir has failed: %1" // lppArgs[0]=(LONG_PTR)lpDirectory; LogFormattedMessage(NULL, IDS_MAKEDIR_L, lppArgs); return TRUE; } //////////////////////////////////////////////////////////////////////////////////// // // CopyFileFailed // Write message to log file that CopyFile failed. // //////////////////////////////////////////////////////////////////////////////////// BOOL CopyFileFailed(LPTSTR lpFile,DWORD dwErrorCode) { TCHAR lpMessage[BUFFER_SIZE]; LONG_PTR lppArgs[1]; DWORD MessageID; if ( dwErrorCode) { MessageID = dwErrorCode; } else { MessageID = GetLastError(); } // // "LOG: CopyFile has failed: %1" // LoadString(ghInstance, IDS_COPYFILE_L, lpMessage, ARRAYSIZE(lpMessage)-1); lppArgs[0]=(LONG_PTR)lpFile; FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, lpMessage, 0, 0, lpMessage, ARRAYSIZE(lpMessage)-1, (va_list *)lppArgs); LogMessage(lpMessage); FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, MessageID, 0, lpMessage, ARRAYSIZE(lpMessage)-1, NULL); LogMessage(lpMessage); return TRUE; } //////////////////////////////////////////////////////////////////////////// // // Muisetup_InitInf // // Parameters: // // [OUT] phInf the handle to the INF file opened. // [OUT] pFileQueue the file queue created in this function. // [OUT] pQueueContext the context used by the default queue callback routine included with the Setup API. // //////////////////////////////////////////////////////////////////////////// BOOL Muisetup_InitInf( HWND hDlg, LPTSTR pszInf, HINF *phInf, HSPFILEQ *pFileQueue, PVOID *pQueueContext) { // // Open the Inf file. // *phInf = SetupOpenInfFile(pszInf, NULL, INF_STYLE_WIN4, NULL); if (*phInf == INVALID_HANDLE_VALUE) { return FALSE; } // // Create a setup file queue and initialize default setup // copy queue callback context. // *pFileQueue = SetupOpenFileQueue(); if ((!*pFileQueue) || (*pFileQueue == INVALID_HANDLE_VALUE)) { SetupCloseInfFile(*phInf); return FALSE; } *pQueueContext = SetupInitDefaultQueueCallback(hDlg); if (!*pQueueContext) { SetupCloseFileQueue(*pFileQueue); SetupCloseInfFile(*phInf); return FALSE; } // // Return success. // return TRUE; } //////////////////////////////////////////////////////////////////////////// // // Muisetup_CloseInf // //////////////////////////////////////////////////////////////////////////// BOOL Muisetup_CloseInf( HINF hInf, HSPFILEQ FileQueue, PVOID QueueContext) { // // Terminate the Queue. // SetupTermDefaultQueueCallback(QueueContext); // // Close the file queue. // SetupCloseFileQueue(FileQueue); // // Close the Inf file. // SetupCloseInfFile(hInf); return TRUE; } UINT MySetupQueueCallback ( PVOID QueueContext, UINT Notification, UINT_PTR Param1, UINT_PTR Param2 ) { UINT status; PFILEPATHS FilePaths = (PFILEPATHS)Param1; PSOURCE_MEDIA SourceMedia = (PSOURCE_MEDIA)Param1; TCHAR szFileName[MAX_PATH]; int iLen; if(Notification == SPFILENOTIFY_NEEDMEDIA) { if(SourceMedia->SourcePath && SourceMedia->SourceFile) { _tcscpy(szFileName,SourceMedia->SourcePath); _tcscat(szFileName,TEXT("\\")); _tcscat(szFileName,SourceMedia->SourceFile); if (!FileExists(szFileName)) { CopyFileFailed(szFileName,ERROR_FILE_NOT_FOUND); g_IECopyError=TRUE; return FILEOP_SKIP; } } } if (Notification == SPFILENOTIFY_COPYERROR) { CopyFileFailed((LPTSTR)FilePaths->Source,ERROR_FILE_NOT_FOUND); g_IECopyError=TRUE; return FILEOP_SKIP; } // // Special for .htt file // // Sign webvw htt files in order for the shell to grant them security privilege to execute stuff. // if ( (Notification == SPFILENOTIFY_ENDCOPY) && (FilePaths->Win32Error == ERROR_SUCCESS)) { iLen=_tcslen(FilePaths->Target); if (iLen > 4) { if (_tcsicmp(&FilePaths->Target[iLen - 4], TEXT(".htt")) == 0) { SHRegisterValidateTemplate(FilePaths->Target,SHRVT_REGISTER); } } } status= SetupDefaultQueueCallback(QueueContext,Notification, Param1, Param2); if (status == FILEOP_ABORT) { g_InstallCancelled = TRUE; } return status; } //////////////////////////////////////////////////////////////////////////////////// // // ExecuteComponentINF // // Installs component MUI files, by running the specified INF file. // // Parameters: // pComponentName the name of the component (e.g. "ie5") // pComponentInfFile: the full path of the component INF file. // pInstallSection the section in the component INF file to be executed. (e.g "DefaultInstall" or "Uninstall") // //////////////////////////////////////////////////////////////////////////////////// BOOL ExecuteComponentINF( HWND hDlg, PTSTR pComponentName, PTSTR pComponentInfFile, PTSTR pInstallSection, BOOL bInstall) { int iLen; TCHAR tchCommandParam[BUFFER_SIZE]; CHAR chCommandParam[BUFFER_SIZE*sizeof(TCHAR)]; HINF hCompInf; // the handle to the component INF file. HSPFILEQ FileQueue; PVOID QueueContext; BOOL bRet = TRUE; DWORD dwResult; LONG_PTR lppArgs[3]; TCHAR szBuffer[BUFFER_SIZE]; // // Advpack LaunchINFSection() command line format: // INF file, INF section, flags, reboot string // 'N' or 'n' in reboot string means no reboot message popup. // wsprintf(tchCommandParam, TEXT("%s,%s,0,n"), pComponentInfFile, pInstallSection); WideCharToMultiByte(CP_ACP, 0, tchCommandParam, -1, chCommandParam, sizeof(chCommandParam), NULL, NULL); if (FileExists(pComponentInfFile)) { // gpfnLaunchINFSection won't be NULL since InitializePFNs() already verifies that. if ((gpfnLaunchINFSection)(hDlg, ghInstance, chCommandParam, SW_SHOW) != S_OK) { lppArgs[0] = (LONG_PTR)pComponentName; DoMessageBoxFromResource(hDlg, ghInstance, bInstall? IDS_ERROR_INSTALL_COMP_UI : IDS_ERROR_UNINSTALL_COMP_UI, lppArgs, IDS_ERROR_T, MB_OK); return (FALSE); } } return (TRUE); } //////////////////////////////////////////////////////////////////////////////////// // // CheckProductType // // Check product type of W2K // //////////////////////////////////////////////////////////////////////////////////// BOOL CheckProductType(INT_PTR nType) { OSVERSIONINFOEX verinfo; INT64 dwConditionMask=0; BOOL bResult=FALSE; DWORD dwTypeMask = VER_PRODUCT_TYPE; memset(&verinfo,0,sizeof(verinfo)); verinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); VER_SET_CONDITION(dwConditionMask,VER_PRODUCT_TYPE,VER_EQUAL); switch (nType) { // W2K Professional case MUI_IS_WIN2K_PRO: verinfo.wProductType=VER_NT_WORKSTATION; break; // W2K Server case MUI_IS_WIN2K_SERVER: verinfo.wProductType=VER_NT_SERVER; break; // W2K Advanced Server or Data Center case MUI_IS_WIN2K_ADV_SERVER_OR_DATACENTER: verinfo.wProductType=VER_NT_SERVER; verinfo.wSuiteMask =VER_SUITE_ENTERPRISE; VER_SET_CONDITION(dwConditionMask,VER_SUITENAME,VER_OR); dwTypeMask = VER_PRODUCT_TYPE | VER_SUITENAME; break; // W2k Data Center case MUI_IS_WIN2K_DATACENTER: verinfo.wProductType=VER_NT_SERVER; verinfo.wSuiteMask =VER_SUITE_DATACENTER; VER_SET_CONDITION(dwConditionMask,VER_SUITENAME,VER_OR); dwTypeMask = VER_PRODUCT_TYPE | VER_SUITENAME; break; // W2K Domain Controller case MUI_IS_WIN2K_DC: verinfo.wProductType=VER_NT_DOMAIN_CONTROLLER; break; case MUI_IS_WIN2K_ENTERPRISE: verinfo.wProductType=VER_NT_DOMAIN_CONTROLLER; verinfo.wSuiteMask =VER_SUITE_ENTERPRISE; VER_SET_CONDITION(dwConditionMask,VER_SUITENAME,VER_OR); dwTypeMask = VER_PRODUCT_TYPE | VER_SUITENAME; break; case MUI_IS_WIN2K_DC_DATACENTER: verinfo.wProductType=VER_NT_DOMAIN_CONTROLLER; verinfo.wSuiteMask =VER_SUITE_DATACENTER; VER_SET_CONDITION(dwConditionMask,VER_SUITENAME,VER_OR); dwTypeMask = VER_PRODUCT_TYPE | VER_SUITENAME; break; // Whistler Personal case MUI_IS_WIN2K_PERSONAL: verinfo.wProductType=VER_NT_WORKSTATION; verinfo.wSuiteMask =VER_SUITE_PERSONAL; VER_SET_CONDITION(dwConditionMask,VER_SUITENAME,VER_AND); dwTypeMask = VER_PRODUCT_TYPE | VER_SUITENAME; break; default: verinfo.wProductType=VER_NT_WORKSTATION; break; } return (VerifyVersionInfo(&verinfo,dwTypeMask,dwConditionMask)); }