/*++ Copyright (c) 1995 Microsoft Corporation Module Name: cmdline.c Abstract: Routines to fetch parameters passed to us by text mode and deal with uniquness criteria. Author: Stephane Plante (t-stepl) 16-Oct-1995 Revision History: 06-Mar-1996 (tedm) massive cleanup, and uniqueness stuff --*/ #include "setupp.h" #pragma hdrstop #ifdef UNICODE #define _UNICODE #endif #include #include "hwlog.h" // // These get filled in when we call SetUpProcessorNaming(). // They are used for legacy purposes. // // PlatformName - a name that indicates the processor platform type; // one of AMD64, I386, or ia64 // // ProcessorName - a description of the type of processor. This varies // depending on PlatformName. // // PrinterPlatform - name of platform-specific part of subdirectory // used in printing architecture. One of w32amd64, // w32x86, or w32ia64. // PCWSTR PlatformName = L""; PCWSTR ProcessorName = L""; PCWSTR PrinterPlatform = L""; GUID DriverVerifyGuid = DRIVER_ACTION_VERIFY; // // Source path used for legacy operations. This is the regular // source path with a platform-specific piece appended to it. // This is how legacy infs expect it. // WCHAR LegacySourcePath[MAX_PATH]; // // Policy values (ignore, warn, or block) for driver and non-driver signing. // These are the policy values that are in effect post-setup (i.e., they are // applied when setup is finished by calling InitializeCodeSigningPolicies with // FALSE). // BYTE DrvSignPolicy; BYTE NonDrvSignPolicy; // // Flags indicating whether the driver and non-driver signing policies came // from the answerfile. (If so, then those values are in effect after GUI-mode // setup as well, thus DrvSignPolicy and NonDrvSignPolicy values are ignored.) // BOOL AFDrvSignPolicySpecified = FALSE; BOOL AFNonDrvSignPolicySpecified = FALSE; // // Flag indicating if we're installing from a CD. // BOOL gInstallingFromCD = FALSE; // // Cryptographically secure codesigning policies // DWORD PnpSeed = 0; // // Define maximum parameter (from answer file) length // #define MAX_PARAM_LEN 256 #define FILEUTIL_HORRIBLE_PATHNAME (_T("system32\\CatRoot\\{F750E6C3-38EE-11D1-85E5-00C04FC295EE}\\")) BOOL SpSetupProcessSourcePath( IN PCWSTR NtPath, OUT PWSTR *DosPath ); NTSTATUS SpSetupLocateSourceCdRom( OUT PWSTR NtPath ); VOID SetUpProcessorNaming( VOID ); BOOL IntegrateUniquenessInfo( IN PCWSTR DatabaseFile, IN PCWSTR UniqueId ); BOOL ProcessOneUniquenessSection( IN HINF Database, IN PCWSTR SectionName, IN PCWSTR UniqueId ); DWORD InstallProductCatalogs( OUT SetupapiVerifyProblem *Problem, OUT LPWSTR ProblemFile, IN LPCWSTR DescriptionForError OPTIONAL ); DWORD DeleteOldCatalogs( VOID ); VOID InstallPrivateFiles( IN HWND Billboard ); DWORD PrepDllCache( VOID ); VOID SpUninstallExcepPackCatalogs( IN HCATADMIN CatAdminHandle OPTIONAL ); BOOL SpSetupLoadParameter( IN PCWSTR Param, OUT PWSTR Answer, IN UINT AnswerBufLen ) /*++ Routine Description: Load a single parameter out of the [Data] section of the setup parameters file. If the datum is not found there then look in the [SetupParams] and [Unattended] sections also. Arguments: Param - supplies name of parameter, which is passed to the profile APIs. Answer - receives the value of the parameter, if successful. AnswerBufLen - supplies the size in characters of the buffer pointed to by Answer. Return Value: Boolean value indicating success or failure. --*/ { if(!AnswerFile[0]) { // // We haven't calculated the path to $winnt$.inf yet // GetSystemDirectory(AnswerFile,MAX_PATH); pSetupConcatenatePaths(AnswerFile,WINNT_GUI_FILE,MAX_PATH,NULL); if(!FileExists(AnswerFile,NULL)) { // // Don't log this error message in mini-setup. Mini-setup may delete // the answer file and later, if someone asks for it, and it is not found // we don't want to log this as a failure. OOBE pretends to be mini-setup // so make sure that we log this error if we're running in OOBE and // we're missing the answer file. // if (!MiniSetup || OobeSetup) { SetuplogError( LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSINFBAD, AnswerFile, NULL,NULL); } return FALSE; } } if(!GetPrivateProfileString(pwData,Param,pwNull,Answer,AnswerBufLen,AnswerFile)) { // // If answer isn't in the DATA section then it could // conceivably be in the SETUPPARAMS section as a user // specified (command line) option // if(!GetPrivateProfileString(pwSetupParams,Param,pwNull,Answer,AnswerBufLen,AnswerFile)) { // // Now check the UNATTENDED section. // if(!GetPrivateProfileString(pwUnattended,Param,pwNull,Answer,AnswerBufLen,AnswerFile)) { // // Now check the ACCESSIBILITY section. // if(!GetPrivateProfileString(pwAccessibility,Param,pwNull,Answer,AnswerBufLen,AnswerFile)) { // // We haven't found the answer here so it probably doesn't exist. // This is an error situation so notify our caller of that. // SetupDebugPrint1(L"SETUP: SpSetupLoadParameter was unable to find %ws.", Param); return(FALSE); } } } } // // Success. // return(TRUE); } BOOL SpSetProductTypeFromParameters( VOID ) /*++ Routine Description: Reads the Product Type from the parameters files and sets up the ProductType global variable. Arguments: None Returns: Boolean value indicating outcome. --*/ { WCHAR p[MAX_PARAM_LEN]; // // Determine the product type. If we can't resolve this // then the installation is in a lot of trouble // if( !MiniSetup ) { if( !SpSetupLoadParameter(pwProduct,p,sizeof(p)/sizeof(p[0]))) { return( FALSE ); } } else { DWORD rc, d, Type; HKEY hKey; // // If we're doing a minisetup then we need to go pull the // product string out of the registry. // // // Open the key. // rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions", 0, KEY_READ, &hKey ); if( rc != NO_ERROR ) { SetLastError( rc ); SetupDebugPrint1( L"Setup: Failed to open ProductOptions key (gle %u) \n", rc ); return( FALSE ); } // // Get the size of the ProductType entry. // rc = RegQueryValueEx( hKey, L"ProductType", NULL, &Type, NULL, &d ); if( rc != NO_ERROR ) { SetLastError( rc ); SetupDebugPrint1( L"Setup: Failed to query size of ProductType key (gle %u) \n", rc ); return( FALSE ); } // // Get the ProductType entry. // rc = RegQueryValueEx( hKey, L"ProductType", NULL, &Type, (LPBYTE)p, &d ); if( rc != NO_ERROR ) { SetLastError( rc ); SetupDebugPrint1( L"Setup: Failed to query ProductType key (gle %u) \n", rc ); return( FALSE ); } } // // We managed to find an entry in the parameters file // so we *should* be able to decode it // if(!lstrcmpi(p,pwWinNt)) { // // We have a WINNT product // ProductType = PRODUCT_WORKSTATION; } else if(!lstrcmpi(p,pwLanmanNt)) { // // We have a PRIMARY SERVER product // ProductType = PRODUCT_SERVER_PRIMARY; } else if(!lstrcmpi(p,pwServerNt)) { // // We have a STANDALONE SERVER product // NOTE: this case can currently never occur, since text mode // always sets WINNT_D_PRODUCT to lanmannt or winnt. // ProductType = PRODUCT_SERVER_STANDALONE; } else { // // We can't determine what we are, so fail // return (FALSE); } return (TRUE); } BOOL SpSetUnattendModeFromParameters( VOID ) /*++ Routine Description: Reads the Unattended Mode from the parameters files and sets up the UnattendMode global variable. Arguments: None Returns: Boolean value indicating outcome. --*/ { WCHAR p[MAX_PARAM_LEN]; // // If we're not running unattended, don't bother to look up the mode. // if(!Unattended) { UnattendMode = UAM_GUIATTENDED; TextmodeEula = TRUE; return TRUE; } if (SpSetupLoadParameter(pwWaitForReboot, p, sizeof(p)/sizeof(p[0]))) { if (!lstrcmpi(p, pwYes)) { UnattendWaitForReboot = TRUE; } } if(SpSetupLoadParameter(pwUnattendMode,p,sizeof(p)/sizeof(p[0]))) { // // We managed to find an entry in the parameters file // so we *should* be able to decode it // if(!lstrcmpi(p,pwGuiAttended)) { // // GUI mode will be fully attended. // UnattendMode = UAM_GUIATTENDED; Unattended = FALSE; } else if(!lstrcmpi(p,pwProvideDefault)) { // // Answers are defaults and can be changed. // UnattendMode = UAM_PROVIDEDEFAULT; } else if(!lstrcmpi(p,pwDefaultHide)) { // // Answers are defaults, but a page with all answers supplied is // not shown. // UnattendMode = UAM_DEFAULTHIDE; } else if(!lstrcmpi(p,pwReadOnly)) { // // All supplied answers are read-only. If a page has all its // answers supplied, then it is not shown. // UnattendMode = UAM_READONLY; } else if(!lstrcmpi(p,pwFullUnattended)) { // // Setup is fully unattended. If we have to ask the user for an // answer, we put up an error dialog. // UnattendMode = UAM_FULLUNATTENDED; } else { // // We can't determine what we are, so use a default // UnattendMode = UAM_DEFAULTHIDE; SetupDebugPrint1( L"SETUP: SpSetUnattendModeFromParameters did not recognize %ls", p ); } } else { // // Use default mode since none was specified. // UnattendMode = UAM_DEFAULTHIDE; } return TRUE; } BOOL SpSetupProcessParameters( IN OUT HWND *Billboard ) /*++ Routine Description: Reads in parameters passed in from TextMode Setup Arguments: Billboard - on input supplies window handle of "Setup is Initializing" billboard. On ouput receives new window handle if we had to display our own ui (in which case we would have killed and then redisplayed the billboard). Returns: Boolean value indicating outcome. --*/ { BOOL b = TRUE; PWSTR q; WCHAR p[MAX_PARAM_LEN]; WCHAR Num[24]; UINT Type; WCHAR c; WCHAR TitleStringBuffer[1024]; DWORD Err; SetupapiVerifyProblem Problem; WCHAR ProblemFile[MAX_PATH]; INITCOMMONCONTROLSEX ControlInit; if(!SpSetProductTypeFromParameters()) { return(FALSE); } // // Is winnt/winnt32-based? // if((b = SpSetupLoadParameter(pwMsDos,p,MAX_PARAM_LEN)) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { WinntBased = TRUE; #ifdef _X86_ // // Get Floppyless boot path, which is given if // pwBootPath is not set to NO // FloppylessBootPath[0] = 0; if((b = SpSetupLoadParameter(pwBootPath,p,MAX_PARAM_LEN)) && lstrcmpi(p,pwNo)) { if(q = NtFullPathToDosPath(p)) { lstrcpyn( FloppylessBootPath, q, sizeof(FloppylessBootPath)/sizeof(FloppylessBootPath[0]) ); MyFree(q); } } #endif } else { WinntBased = FALSE; } // // Win3.1 or Win95 upgrade? // Win31Upgrade = (b && (b = SpSetupLoadParameter(pwWin31Upgrade,p,MAX_PARAM_LEN)) && !lstrcmpi(p,pwYes)); Win95Upgrade = (b && (b = SpSetupLoadParameter(pwWin95Upgrade,p,MAX_PARAM_LEN)) && !lstrcmpi(p,pwYes)); // // NT Upgrade? // Upgrade = (b && (b = SpSetupLoadParameter(pwNtUpgrade,p,MAX_PARAM_LEN)) && !lstrcmpi(p,pwYes)); SetEnvironmentVariable( L"Upgrade", Upgrade ? L"True" : L"False" ); // // If this is a an upgrade of or to a standalone server, // change the product type to standalone server. // // If this is not an upgrade and the product type is lanmannt, // change to standalone server. This makes the default server type // non-dc. // if(b && ((!Upgrade && (ProductType != PRODUCT_WORKSTATION)) || ((b = SpSetupLoadParameter(pwServerUpgrade,p,MAX_PARAM_LEN)) && !lstrcmpi(p,pwYes)))) { MYASSERT(ISDC(ProductType)); ProductType = PRODUCT_SERVER_STANDALONE; } if( ProductType == PRODUCT_WORKSTATION) { if( GetProductFlavor() == 4) { SetupTitleStringId = Upgrade ? IDS_TITLE_UPGRADE_P : IDS_TITLE_INSTALL_P; } else { SetupTitleStringId = Upgrade ? IDS_TITLE_UPGRADE_W : IDS_TITLE_INSTALL_W; } } else { SetupTitleStringId = Upgrade ? IDS_TITLE_UPGRADE_S : IDS_TITLE_INSTALL_S; } // // Fetch the source directory and convert it to DOS-style path // if(b && (b = SpSetupLoadParameter(pwSrcDir,p,MAX_PARAM_LEN))) { // // Remember that setupdll.dll does all sorts of checking on the // source path. We need todo the same checks here. Note that // we will *write* back the checked path into $winnt$.inf as a // logical step to take // if(SpSetupProcessSourcePath(p,&q)) { lstrcpyn(SourcePath,q,sizeof(SourcePath)/sizeof(SourcePath[0])); MyFree(q); // // Attempt to write the path to the parameters file. // This changes it from an nt-style path to a dos-style path there. // b = WritePrivateProfileString(pwData,pwDosDir,SourcePath,AnswerFile); if(!b) { SetupDebugPrint( L"SETUP: WritePrivateProfileString failed in SpSetupProcessParameters." ); } } else { b = FALSE; SetupDebugPrint( L"SETUP: SpSetupProcessSourcePath failed in SpSetupProcessParameters." ); } // // Set up globals for platform-specific info // SetUpProcessorNaming(); // // Construct legacy source path. // if(b) { lstrcpyn(LegacySourcePath,SourcePath,MAX_PATH); pSetupConcatenatePaths(LegacySourcePath,PlatformName,MAX_PATH,NULL); } } // // Unattended Mode? // Unattended = (b && (b = SpSetupLoadParameter(pwInstall,p,MAX_PARAM_LEN)) && !lstrcmpi(p,pwYes)); if(b) { if( !(b = SpSetUnattendModeFromParameters()) ) { SetupDebugPrint( L"SETUP: SpSetUnattendModeFromParameters failed in SpSetupProcessParameters." ); } } SetupDebugPrint1(L"SETUP: Upgrade=%d.", Upgrade); SetupDebugPrint1(L"SETUP: Unattended=%d.", Unattended); // // We can get into unattended mode in several ways, so we also check whether // the "/unattend" switch was explicitly specified. // UnattendSwitch = (b && SpSetupLoadParameter(pwUnattendSwitch,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))); // // Should we force OOBE to run? // ForceRunOobe = (b && SpSetupLoadParameter(pwRunOobe,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))); // // Flag indicating whether we are in a special mode for OEM's to use on the // factory floor. // ReferenceMachine = (b && SpSetupLoadParameter(pwReferenceMachine,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))); // // Eula already displayed? // if(b && SpSetupLoadParameter(pwEulaDone,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { EulaComplete = TRUE; } else { EulaComplete = FALSE; } // // Do uniqueness stuff now. We do this here so we don't have to // reinitialize anything. All the stuff above is not subject to change // via uniquenss. // InitializeUniqueness(Billboard); // // Initialize unattended operation now. // UnattendInitialize(); // // Setup shell special folders (e.g., "Program Files", etc.) in registry // prior to loading any INFs with setupapi. That's because it's possible // that an INF can have DIRIDs that refer to these special directories. // (In addition to setupapi's potential need for this, OCM definitely needs // it.) // if(b) { if( !(b = SetProgramFilesDirInRegistry()) ) { SetupDebugPrint( L"SETUP: SetProgramFilesDirInRegistry failed in SpSetupProcessParameters." ); } } // // Also, let setupapi know where the source path is... // // note that the servicepack sourcepath is the same as the system source // path in this case since we can only be dealing with a slipstreamed // build in this case // if(b) { if( !(b = pSetupSetSystemSourcePath( SourcePath, SourcePath )) ) { SetupDebugPrint( L"SETUP: pSetupSetSystemSourcePath failed in SpSetupProcessParameters." ); } } if(b && SpSetupLoadParameter(pwIncludeCatalog,p,MAX_PARAM_LEN) && *p) { IncludeCatalog = pSetupDuplicateString(p); if(!IncludeCatalog) { b = FALSE; SetupDebugPrint( L"SETUP: IncludeCatalog failed in SpSetupProcessParameters." ); } } if(b) { // // Load the system setup (win95-style!) infs. // SyssetupInf = SetupOpenInfFile(L"syssetup.inf",NULL,INF_STYLE_WIN4,NULL); if(SyssetupInf == INVALID_HANDLE_VALUE) { KillBillboard(*Billboard); FatalError(MSG_LOG_SYSINFBAD,L"syssetup.inf",0,0); } // // syssetup.inf opened successfully, now append-load any layout INFs // it references. // if(!SetupOpenAppendInfFile(NULL,SyssetupInf,NULL)) { KillBillboard(*Billboard); FatalError(MSG_LOG_SYSINFBAD,L"(syssetup.inf layout)",0,0); } // // write some information about the hardware configuration to setupact.log // // if( !OobeSetup ) { SP_LOG_HARDWARE_IN LogHardwareIn = { 0 }; LogHardwareIn.SetuplogError = SetuplogError; SpLogHardware(&LogHardwareIn); } if (!MiniSetup && !OobeSetup) { DuInitialize (); } // // install side by side assemblies (fusion) // if( !OobeSetup ) { SIDE_BY_SIDE SideBySide = {0}; BOOL b1 = FALSE; BOOL b2 = FALSE; BOOL b3 = FALSE; b1 = SideBySidePopulateCopyQueue(&SideBySide, NULL, NULL); b2 = SideBySideFinish(&SideBySide, b1); if (!b1 || !b2) { WCHAR szErrorBuffer[128]; DWORD dwLastError = GetLastError(); szErrorBuffer[0] = 0; if (FormatMessageW( FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError, 0, szErrorBuffer, RTL_NUMBER_OF(szErrorBuffer), NULL) == 0) { _snwprintf(szErrorBuffer, RTL_NUMBER_OF(szErrorBuffer), L"Untranslatable message, Win32LastError is %lu\r\n", dwLastError); szErrorBuffer[RTL_NUMBER_OF(szErrorBuffer) - 1] = 0; } if ((dwLastError == ERROR_CRC) || (dwLastError == ERROR_SWAPERROR)) { // for CD media error FatalError(MSG_LOG_SIDE_BY_SIDE_IO_ERROR, szErrorBuffer, 0, 0); }else { FatalError(MSG_LOG_SIDE_BY_SIDE, szErrorBuffer, 0, 0); } } // // install additional assemblies downloaded from WU // ignore any errors; logging occurs inside the called function // // Meta-issue: Perhaps this should use the SideBySide context // created above, rather than generating its own thing? // That would allow even more "goodness" by piggybacking on the // existing structures, reduce memory usage by not creating // another context, and then chain all the copy calls (if/when // SxS uses the real copy queue functionality) into a single // SideBySideFinish. // if (!MiniSetup && !OobeSetup) { DuInstallDuAsms (); } // // Everyone done and happy? Good, now go and create the default // context based on whatever DU and the original media installed. // b3 = SideBySideCreateSyssetupContext(); if ( !b3 ) { WCHAR szErrorBuffer[128]; DWORD dwLastError = GetLastError(); szErrorBuffer[0] = 0; if (FormatMessageW( FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError, 0, szErrorBuffer, RTL_NUMBER_OF(szErrorBuffer), NULL) == 0) { _snwprintf(szErrorBuffer, RTL_NUMBER_OF(szErrorBuffer), L"Untranslatable message, Win32LastError is %lu\r\n", dwLastError); szErrorBuffer[RTL_NUMBER_OF(szErrorBuffer) - 1] = 0; } if ((dwLastError == ERROR_CRC) || (dwLastError == ERROR_SWAPERROR)) { // for CD media error FatalError(MSG_LOG_SIDE_BY_SIDE_IO_ERROR, szErrorBuffer, 0, 0); }else { FatalError(MSG_LOG_SIDE_BY_SIDE, szErrorBuffer, 0, 0); } } } // // We must not use comctl32.dll until after SideBySide install completes. // It is delayloaded, using the linker feature. // // But, actually, it get's loaded by winntbb before us, and that is ok, it // still gets redirected for uses from syssetup.dll, oc manager, etc. // //ASSERT(GetModuleHandleW(L"comctl32.dll") == NULL); ControlInit.dwSize = sizeof(INITCOMMONCONTROLSEX); ControlInit.dwICC = ICC_LISTVIEW_CLASSES | ICC_TREEVIEW_CLASSES | ICC_BAR_CLASSES | ICC_TAB_CLASSES | ICC_UPDOWN_CLASS | ICC_PROGRESS_CLASS | ICC_HOTKEY_CLASS | ICC_ANIMATE_CLASS | ICC_WIN95_CLASSES | ICC_DATE_CLASSES | ICC_USEREX_CLASSES | ICC_COOL_CLASSES #if (_WIN32_IE >= 0x0400) | ICC_INTERNET_CLASSES | ICC_PAGESCROLLER_CLASS #endif ; InitCommonControlsEx( &ControlInit ); // // We're about to go off and install the catalogs that will be used for // digital signature verification of the product files. First, however, // we need to make sure all the CAPI stuff is setup. (Errors here are // not considered fatal.) // if(!InstallOrUpgradeCapi()) { SetupDebugPrint(L"Setup: (non-critical error) Failed call InstallOrUpgradeCapi().\n"); } // // Now go install the product catalog files, validating syssetup.inf // (and any append-loaded INFs) against the 'primary' catalog. // // NOTE: No file/INF operations using setupapi should be done until after // the product catalogs are installed! // if(!LoadString(MyModuleHandle, SetupTitleStringId, TitleStringBuffer, SIZECHARS(TitleStringBuffer))) { *TitleStringBuffer = L'\0'; } // // delete old catalogs that we don't want anymore before we install // our product catalogs // DeleteOldCatalogs(); Err = InstallProductCatalogs(&Problem, ProblemFile, (*TitleStringBuffer ? TitleStringBuffer : NULL) ); if(Err == NO_ERROR) { if (!MiniSetup && !OobeSetup) { Err = DuInstallCatalogs ( &Problem, ProblemFile, (*TitleStringBuffer ? TitleStringBuffer : NULL) ); if (Err != NO_ERROR) { // // We couldn't install updates. However, there's not // a whole lot we can do about it. We'll just log an error for this // SetuplogError( LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSSETUP_UPDATES_FAILED, (*TitleStringBuffer ? TitleStringBuffer : ProblemFile), Err, ProblemFile, NULL, NULL ); // // Also, add an entry about this failure to setupapi's PSS exception // logfile. // pSetupHandleFailedVerification ( MainWindowHandle, Problem, ProblemFile, (*TitleStringBuffer ? TitleStringBuffer : NULL), pSetupGetCurrentDriverSigningPolicy(FALSE), TRUE, // no UI! Err, NULL, NULL, NULL ); } } } PnpSeed = GetSeed(); // // At this point setupapi can verify files/INFs. // pSetupSetGlobalFlags(pSetupGetGlobalFlags()&~PSPGF_NO_VERIFY_INF); // // Now that we can use crypto, we initialize our codesigning policy // values. (We have to do this here, because we're about to retrieve // policy in the error handling code below.) // InitializeCodeSigningPolicies(TRUE); if(Err != NO_ERROR) { // // We couldn't install the product catalogs (or syssetup.inf // couldn't be verified using that catalog). However, there's not // a whole lot we can do about it. We'll just log an error for // this, and components that need to be verified later on will // (based on policy) generate signature verification failure popups. // if( Err == CERT_E_EXPIRED) { SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSSETUP_CERT_EXPIRED, Err, NULL, NULL ); } else { SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSSETUP_VERIFY_FAILED, (*TitleStringBuffer ? TitleStringBuffer : ProblemFile), Err, NULL, SETUPLOG_USE_MESSAGEID, Err, NULL, NULL ); } // // Also, add an entry about this failure to setupapi's PSS exception // logfile. // pSetupHandleFailedVerification(MainWindowHandle, Problem, ProblemFile, (*TitleStringBuffer ? TitleStringBuffer : NULL), pSetupGetCurrentDriverSigningPolicy(FALSE), TRUE, // no UI! Err, NULL, // log context NULL, //optional flags NULL ); KillBillboard(*Billboard); FatalError(MSG_LOG_SYSSETUP_CATALOGS_NOT_INSTALLED,0,0); } // // make sure to install the private files (specified with /m) // BEFORE calling DuInstallUpdates () // InstallPrivateFiles(*Billboard); if (!MiniSetup && !OobeSetup) { // // install any updated files, previously // downloaded and preprocessed by winnt32 // if it fails, it already logged the reason // DuInstallUpdates (); } if( (Err=PrepDllCache()) != NO_ERROR ){ SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_MAKEDLLCACHE_CATALOGS_FAILED, Err, NULL, SETUPLOG_USE_MESSAGEID, Err, NULL, NULL ); } } // // Accessibility Utilities // AccessibleSetup = FALSE; if(SpSetupLoadParameter(pwAccMagnifier,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { AccessibleSetup = TRUE; Magnifier = TRUE; } else { Magnifier = FALSE; } if(SpSetupLoadParameter(pwAccReader,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { AccessibleSetup = TRUE; ScreenReader = TRUE; } else { ScreenReader = FALSE; } if(SpSetupLoadParameter(pwAccKeyboard,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { AccessibleSetup = TRUE; OnScreenKeyboard = TRUE; } else { OnScreenKeyboard = FALSE; } // // Fetch original source path and source path type. // We either deal with network or CD-ROM. // if(b) { Type = DRIVE_CDROM; lstrcpy(p,L"A:\\"); lstrcat(p,PlatformName); if(SpSetupLoadParameter(WINNT_D_ORI_SRCPATH,p,MAX_PARAM_LEN) && SpSetupLoadParameter(WINNT_D_ORI_SRCTYPE,Num,sizeof(Num)/sizeof(Num[0]))) { Type = wcstoul(Num,NULL,10); if(Type != DRIVE_REMOTE && Type != DRIVE_FIXED) { Type = DRIVE_CDROM; } } if(Type == DRIVE_CDROM) { // // Make sure the drive is a CD-ROM, as the drive letters // may be different then when winnt/winnt32 was run. // if(MyGetDriveType(p[0]) != DRIVE_CDROM) { for(c=L'A'; c<=L'Z'; c++) { if(MyGetDriveType(c) == DRIVE_CDROM) { p[0] = c; break; } } if(MyGetDriveType(p[0]) != DRIVE_CDROM) { // // No CD-ROM drives. Change to A:. // lstrcpy(p,L"A:\\"); lstrcat(p,PlatformName); } } } // // Root paths should be like x:\ and not just x:. // if(p[0] && (p[1] == L':') && !p[2]) { p[2] = L'\\'; p[3] = 0; } OriginalSourcePath = pSetupDuplicateString(p); if(!OriginalSourcePath) { b = FALSE; SetupDebugPrint( L"SETUP: pSetupDuplicateString failed in SpSetupProcessParameters." ); } } // // The following parameters are optional. // - Any optional dirs to copy over? // - User specified command to execute // - Skip Missing Files? // if(b && SpSetupLoadParameter(pwOptionalDirs,p,MAX_PARAM_LEN) && *p) { OptionalDirSpec = pSetupDuplicateString(p); if(!OptionalDirSpec) { b=FALSE; } } if(b && SpSetupLoadParameter(pwUXC,p,MAX_PARAM_LEN) && *p) { UserExecuteCmd = pSetupDuplicateString(p); if(!UserExecuteCmd) { b = FALSE; SetupDebugPrint( L"SETUP: pSetupDuplicateString failed in SpSetupProcessParameters." ); } } if(b && SpSetupLoadParameter(pwSkipMissing,p,MAX_PARAM_LEN) && (!lstrcmpi(p,pwYes) || !lstrcmpi(p,pwOne))) { SkipMissingFiles = TRUE; } return(b); } NTSTATUS SpSetupLocateSourceCdRom( OUT PWSTR NtPath ) /*++ Routine Description: Searches all the available CD-ROM devices for source media and returns the NT device name for the first CD-ROM that has the source media. Currently we use tag file name to validate the source media. Arguments: NtPath - Place holder for receiving NT device name for CD-ROM that has the source media. Returns: Appropriate NTSTATUS code. --*/ { NTSTATUS Status = STATUS_INVALID_PARAMETER; if (NtPath) { WCHAR LayoutInf[MAX_PATH]; if (GetWindowsDirectory(LayoutInf, ARRAYSIZE(LayoutInf))) { WCHAR TagFileName[MAX_PATH]; pSetupConcatenatePaths(LayoutInf, TEXT("\\inf\\layout.inf"), ARRAYSIZE(TagFileName), NULL); if (GetPrivateProfileString(TEXT("strings"), TEXT("cdtagfile"), TEXT(""), TagFileName, ARRAYSIZE(TagFileName), LayoutInf)) { SYSTEM_DEVICE_INFORMATION SysDeviceInfo = {0}; Status = NtQuerySystemInformation(SystemDeviceInformation, &SysDeviceInfo, sizeof(SYSTEM_DEVICE_INFORMATION), NULL); if (NT_SUCCESS(Status) && (0 == SysDeviceInfo.NumberOfCdRoms)) { Status = STATUS_OBJECT_NAME_NOT_FOUND; } if (NT_SUCCESS(Status)) { ULONG Index; WCHAR TagFilePathName[MAX_PATH]; WCHAR SourceCdRomPath[MAX_PATH]; UNICODE_STRING UnicodeString; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK StatusBlock; HANDLE FileHandle; UINT OldMode; for (Index = 0; Index < SysDeviceInfo.NumberOfCdRoms; Index++) { wsprintf(SourceCdRomPath, TEXT("\\device\\cdrom%d\\"), Index); wcscpy(TagFilePathName, SourceCdRomPath); pSetupConcatenatePaths(TagFilePathName, TagFileName, ARRAYSIZE(TagFilePathName), NULL); // // See if the NT source path exists. // RtlInitUnicodeString(&UnicodeString, TagFilePathName); InitializeObjectAttributes(&ObjectAttributes, &UnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL); OldMode = SetErrorMode(SEM_FAILCRITICALERRORS); Status = NtCreateFile(&FileHandle, FILE_GENERIC_READ, &ObjectAttributes, &StatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_SYNCHRONOUS_IO_ALERT, NULL, 0); SetErrorMode(OldMode); if(NT_SUCCESS(Status)) { CloseHandle(FileHandle); // // The tag file is present which indicates // the current CD-ROM is this is source CD-ROM // wcscpy(NtPath, SourceCdRomPath); break; } } } } } } return Status; } BOOL SpSetupProcessSourcePath( IN PCWSTR NtPath, OUT PWSTR *DosPath ) { WCHAR ntPath[MAX_PATH]; BOOL NtPathIsCd; PWCHAR PathPart; NTSTATUS Status; OBJECT_ATTRIBUTES ObjectAttributes; UNICODE_STRING UnicodeString; HANDLE Handle; IO_STATUS_BLOCK StatusBlock; UINT OldMode; WCHAR Drive; WCHAR PossibleDosPath[MAX_PATH]; UINT Type; BOOL b; WCHAR LayoutInf[MAX_PATH]; #define CDDEVPATH L"\\DEVICE\\CDROM" #define CDDEVPATHLEN ((sizeof(CDDEVPATH)/sizeof(WCHAR))-1) #define RDRDEVPATH L"\\DEVICE\\LANMANREDIRECTOR" #define RDRDEVPATHLEN ((sizeof(RDRDEVPATH)/sizeof(WCHAR))-1) if (!(NtPath && DosPath)){ SetupDebugPrint( L"SETUP: SpSetupProcessSourcePath Invalid parameters passed to SpSetupProcessSourcepath." ); return FALSE; } // // Determine the source media type based on the nt path // lstrcpyn(ntPath,NtPath,MAX_PATH); CharUpper(ntPath); PathPart = NULL; NtPathIsCd = FALSE; if(wcsstr(ntPath,L"\\DEVICE\\HARDDISK")) { // // Looks like a hard drive; make sure it's really valid. // if(PathPart = wcsstr(ntPath,L"\\PARTITION")) { if(PathPart = wcschr(PathPart+1,L'\\')) { PathPart++; } } } else { if(!memcmp(ntPath,CDDEVPATH,CDDEVPATHLEN*sizeof(WCHAR))) { NtPathIsCd = TRUE; if(PathPart = wcschr(ntPath+CDDEVPATHLEN,L'\\')) { PathPart++; } else { PathPart = wcschr(ntPath,0); } } } // // Set a global here so we can always know if we're installing from // CD. // gInstallingFromCD = NtPathIsCd; // // If the case where we don't recognize the device type, just try to // convert it to a DOS path and return. // if(!PathPart) { if (memcmp(ntPath,RDRDEVPATH,RDRDEVPATHLEN*sizeof(WCHAR)) == 0) { // // Special case for \Device\LanmanRedirector: convert to UNC path. // *DosPath = MyMalloc((lstrlen(ntPath) - RDRDEVPATHLEN + 2)*sizeof(WCHAR)); if (*DosPath != NULL) { wcscpy(*DosPath, L"\\"); wcscat(*DosPath, ntPath + RDRDEVPATHLEN); } // // Set RemoteBootSetup to indicate that we're doing a remote boot // setup. Set BaseCopyStyle to indicate that single-instance store // links should be created instead of copying files. // RemoteBootSetup = TRUE; BaseCopyStyle = SP_COPY_SOURCE_SIS_MASTER; } else { *DosPath = NtFullPathToDosPath(ntPath); } return(*DosPath != NULL); } // // See if the NT source path exists for CDROM. // if (GetWindowsDirectory(LayoutInf, ARRAYSIZE(LayoutInf))) { WCHAR TagFileName[MAX_PATH]; pSetupConcatenatePaths(LayoutInf, TEXT("\\inf\\layout.inf"), ARRAYSIZE(LayoutInf), NULL); // // Get the name of the cd tag file name from layout.inf file // if (GetPrivateProfileString(TEXT("strings"), TEXT("cdtagfile"), TEXT(""), TagFileName, ARRAYSIZE(TagFileName), LayoutInf)) { WCHAR TagFilePathName[MAX_PATH]; HANDLE FileHandle; wcscpy(TagFilePathName, ntPath); pSetupConcatenatePaths( TagFilePathName, TagFileName, ARRAYSIZE(TagFilePathName), NULL); // // Check if the tag file exists in the CDROM media // corresponding to the NtPath passed to us from the // Text mode setup. // It could have changed, if there are more than one CDROM // drives on the computer and more than one contain media // as the order in which they get detected in GUI mode setup // can be different than in Text mode Setup. // RtlInitUnicodeString(&UnicodeString, TagFilePathName); InitializeObjectAttributes(&ObjectAttributes, &UnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL); OldMode = SetErrorMode(SEM_FAILCRITICALERRORS); Status = NtCreateFile(&FileHandle, FILE_GENERIC_READ, &ObjectAttributes, &StatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_SYNCHRONOUS_IO_ALERT, NULL, 0); SetErrorMode(OldMode); // // Tag file exists in the CDROM media represented by NtPath. // if(NT_SUCCESS(Status)) { CloseHandle(FileHandle); // // The tag file is present which indicates // the current CD-ROM is this is source CD-ROM // *DosPath = NtFullPathToDosPath(ntPath); return(*DosPath != NULL); } } } // // Scan for source CD-ROM among available CD-ROM devices // if (NtPathIsCd) { WCHAR NtSourceCdRomPath[MAX_PATH] = {0}; NTSTATUS Status = SpSetupLocateSourceCdRom(NtSourceCdRomPath); if (NT_SUCCESS(Status)) { *DosPath = NtFullPathToDosPath(NtSourceCdRomPath); if (*DosPath) { return TRUE; } } } // // The directory does not exist as-is. Look through all dos drives // to attempt to find the source path. Match the drive types as well. // // When we get here PathPart points past the initial \ in the // part of the nt device path past the device name. Note that this // may be a nul char. // for(Drive = L'A'; Drive <= L'Z'; Drive++) { PossibleDosPath[0] = Drive; PossibleDosPath[1] = L':'; PossibleDosPath[2] = L'\\'; PossibleDosPath[3] = 0; // // NOTE: Removable hard drives and floppies both come back // as DRIVE_REMOVABLE. // Type = GetDriveType(PossibleDosPath); if(((Type == DRIVE_CDROM) && NtPathIsCd) || (((Type == DRIVE_REMOVABLE) || (Type == DRIVE_FIXED)) && !NtPathIsCd)) { // // See whether the path exists. If we're looking for // the root path (such as when installing from a CD, // in which case the ntPath was something like // \Device\CdRom0\) then we can't use FileExists // since that relies on FindFirstFile which fails // on root paths. // if(*PathPart) { lstrcpy(PossibleDosPath+3,PathPart); b = FileExists(PossibleDosPath,NULL); } else { b = GetVolumeInformation( PossibleDosPath, NULL,0, // vol name buffer and size NULL, // serial # NULL, // max comp len NULL, // fs flags NULL,0 // fs name buffer and size ); } if(b) { *DosPath = pSetupDuplicateString(PossibleDosPath); return(*DosPath != NULL); } } } // // Couldn't find it. Try a fall-back. // *DosPath = NtFullPathToDosPath(ntPath); return(*DosPath != NULL); } VOID SetUpProcessorNaming( VOID ) /*++ Routine Description: Determines strings which corresponds to the platform name, processor name and printer platform. For backwards compat. Sets global variables PlatformName - a name that indicates the processor platform type; one of AMD64, I386, or ia64. ProcessorName - a description of the type of processor. This varies depending on PlatformName. PrinterPlatform - name of platform-specific part of subdirectory used in printing architecture. One of w32amd64, w32ia64, or w32x86. Arguments: None Returns: None. Global vars filled in as described above. --*/ { SYSTEM_INFO SystemInfo; GetSystemInfo(&SystemInfo); switch(SystemInfo.wProcessorArchitecture) { case PROCESSOR_ARCHITECTURE_AMD64: ProcessorName = L"AMD64"; PlatformName = L"AMD64"; PrinterPlatform = L"w32amd64"; break; case PROCESSOR_ARCHITECTURE_INTEL: switch(SystemInfo.wProcessorLevel) { case 3: ProcessorName = (!IsNEC_98) ? L"I386" : L"nec98"; //NEC98 break; case 4: ProcessorName = L"I486"; break; case 6: ProcessorName = L"I686"; break; case 5: default: ProcessorName = L"I586"; break; } PlatformName = (!IsNEC_98) ? L"I386" : L"nec98"; //NEC98 PrinterPlatform = L"w32x86"; break; case PROCESSOR_ARCHITECTURE_IA64: ProcessorName = L"Merced"; PlatformName = L"IA64"; PrinterPlatform = L"w32ia64"; break; } // // In default case the vars stay "" which is what they are // statically initialized to. // } VOID InitializeUniqueness( IN OUT HWND *Billboard ) /*++ Routine Description: Initialize uniquess by looking in a database file and overwriting the parameters file with information found in it, based in a unique identifier passed along to us from text mode (and originally winnt/winnt32). There are 2 options: the database was copied into the source path by winnt/ winnt32, or we need to prompt the user to insert a floppy from his admin that contains the database. The user may elect to cancel, which means setup will continue, but the machine will probably not be configured properly. Arguments: Billboard - on input contains handle of currently displayed "Setup is Initializing" billboard. On output contains new handle if this routine had to display UI. We pass this around to avoid annoying flashing of the billboard. Returns: None. --*/ { PWCHAR p; WCHAR UniquenessId[MAX_PARAM_LEN]; WCHAR DatabaseFile[MAX_PATH]; BOOL Prompt; int i; UINT OldMode; BOOL NeedNewBillboard; // // Determine whether uniqueness is even important by looking // for a uniqueness spec in the parameters file. // If the id ends with a * then we expect the uniqueness database file // to be in the source, with a reserved name. Otherwise we need to // prompt for it on a floppy. // if(SpSetupLoadParameter(WINNT_D_UNIQUENESS,UniquenessId,MAX_PARAM_LEN)) { if(p = wcschr(UniquenessId,L'*')) { *p = 0; Prompt = FALSE; } else { Prompt = TRUE; } } else { // // We don't care about uniqueness. // return; } // // If the file is already in the source, attempt to make use of it now. // If this fails tell the user and fall through to the floppy prompt case. // if(!Prompt) { lstrcpy(DatabaseFile,SourcePath); pSetupConcatenatePaths(DatabaseFile,WINNT_UNIQUENESS_DB,MAX_PATH,NULL); if(IntegrateUniquenessInfo(DatabaseFile,UniquenessId)) { return; } MessageBoxFromMessage( MainWindowHandle, MSG_UNIQUENESS_DB_BAD_1, NULL, IDS_WINNT_SETUP, MB_OK | MB_ICONERROR, UniquenessId ); Prompt = TRUE; } lstrcpy(DatabaseFile,L"A:\\"); lstrcat(DatabaseFile,WINNT_UNIQUENESS_DB); OldMode = SetErrorMode(SEM_FAILCRITICALERRORS); if(Prompt) { KillBillboard(*Billboard); NeedNewBillboard = TRUE; } else { NeedNewBillboard = FALSE; } while(Prompt) { i = MessageBoxFromMessage( MainWindowHandle, MSG_UNIQUENESS_DB_PROMPT, NULL, IDS_WINNT_SETUP, MB_OKCANCEL ); if(i == IDOK) { // // User thinks he provided a floppy with the database floppy on it. // if(IntegrateUniquenessInfo(DatabaseFile,UniquenessId)) { Prompt = FALSE; } else { MessageBoxFromMessage( MainWindowHandle, MSG_UNIQUENESS_DB_BAD_2, NULL, IDS_WINNT_SETUP, MB_OK | MB_ICONERROR, UniquenessId ); } } else { // // User cancelled -- verify. // i = MessageBoxFromMessage( MainWindowHandle, MSG_UNIQUENESS_DB_VERIFYCANCEL, NULL, IDS_WINNT_SETUP, MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION ); Prompt = (i != IDYES); } } if(NeedNewBillboard) { *Billboard = DisplayBillboard(MainWindowHandle,MSG_INITIALIZING); } SetErrorMode(OldMode); } BOOL IntegrateUniquenessInfo( IN PCWSTR DatabaseFile, IN PCWSTR UniqueId ) /*++ Routine Description: Apply uniqueness data from a database, based on a unique identifier. The unique identifier is looked up in the [UniqueIds] section of the database file. Each field on the line is the name of a section. Each section's data overwrites existing data in the unattend.txt file. [UniqueIds] Id1 = foo,bar [foo] a = ... b = ... [bar] y = ... etc. Arguments: Database - supplies the name of the uniqueness database (which is opened as a legacy inf for simplicity in parsing). UniqueId - supplies the unique id for this computer. Returns: Boolean value indicating outcome. --*/ { HINF Database; INFCONTEXT InfLine; DWORD SectionCount; PCWSTR SectionName; DWORD i; BOOL b; // // Load the database file as a legacy inf. This makes processing it // a little easier. // Database = SetupOpenInfFile(DatabaseFile,NULL,INF_STYLE_OLDNT,NULL); if(Database == INVALID_HANDLE_VALUE) { b = FALSE; goto c0; } // // Look in the [UniqueIds] section to grab a list of sections // we need to overwrite for this user. If the unique id does not appear // in the database, bail now. If the id exists but there are no sections, // exit with success. // if(!SetupFindFirstLine(Database,L"UniqueIds",UniqueId,&InfLine)) { b = FALSE; goto c1; } SectionCount = SetupGetFieldCount(&InfLine); if(!SectionCount) { b = TRUE; goto c1; } // // Now process each section. // for(b=TRUE,i=0; b && (i= sizeof(SP_INF_INFORMATION)); if(InfInfoBuffer = MyMalloc(RequiredSize)) { if(!SetupGetInfInformation(SyssetupInf, INFINFO_INF_SPEC_IS_HINF, InfInfoBuffer, RequiredSize, NULL)) { // // This should never fail! // Err = GetLastError(); MYASSERT(0); } } else { Err = ERROR_NOT_ENOUGH_MEMORY; } } else { Err = GetLastError(); InfInfoBuffer = NULL; } // // If we encountered an error, then we couldn't retrieve information about // the loaded INFs in syssetup.inf's HINF--this should never happen // (barring an out-of-memory condition), but if it does, just bail. // if(Err != NO_ERROR) { *Problem = SetupapiVerifyInfProblem; lstrcpy(ProblemFile, L"syssetup.inf"); goto clean0; } // // If there's a [SourceDisksFiles] entry for testroot.cer in one of the // append-loaded INFs in syssetup.inf's HINF (specifically, from // layout.inf), then we will go and install that test certificate in the // root store so that the test signatures used for this internal-release-only // build will be verified. We will also install a test root certificate if // one is specified in unattend.txt in the "TestCert" entry in the // [unattended] section. // // If testroot.cer isn't listed in one of the two aforementioned locations, // then we know the files in this build were signed for real, so we want to // delete the test certificate(s), in case we're updating an installation // that was installed previously using a test-signed build. // if(SetupGetSourceFileLocation(SyssetupInf, NULL, L"testroot.cer", &SourceId, NULL, 0, NULL)) { // // Testroot.cer must exist (possibly compressed) in the source // directory. (Regardless of whether testroot.cer is compressed, use // the DecompressedName buffer to temporarily hold this filename.) // lstrcpy(DecompressedName, L"testroot.cer"); } else { GetSystemDirectory(TempBuffer, MAX_PATH); pSetupConcatenatePaths(TempBuffer, WINNT_GUI_FILE, MAX_PATH, NULL); if(GetPrivateProfileString(WINNT_UNATTENDED, WINNT_U_TESTCERT, pwNull, DecompressedName, MAX_PATH, TempBuffer)) { OemTestSigned = TRUE; } } if(*DecompressedName) { Err = SetupAddOrRemoveTestCertificate( DecompressedName, (OemTestSigned ? INVALID_HANDLE_VALUE : SyssetupInf) ); if(Err != NO_ERROR) { SetupDebugPrint2(L"SETUP: SetupAddOrRemoveTestCertificate(%ls) failed. Error = %d \n", DecompressedName, Err ); // // This is considered a critial failure--as we could bugcheck post - setup. // SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSSETUP_CERT_NOT_INSTALLED, DecompressedName, Err, NULL, SETUPLOG_USE_MESSAGEID, Err, NULL, NULL ); // // If this was an internal test-signed build, then point the // accusing finger at syssetup.inf. // if(!OemTestSigned) { *Problem = SetupapiVerifyInfProblem; lstrcpy(ProblemFile, L"syssetup.inf"); } else { *Problem = SetupapiVerifyCatalogProblem; lstrcpy(ProblemFile, DecompressedName); } if(InfInfoBuffer) MyFree(InfInfoBuffer); return Err; } } else { // // testroot.cer isn't listed--remove it from the installation in case // we're upgrading over an internal-release-only test build. // MYASSERT(GetLastError() == ERROR_LINE_NOT_FOUND); Err = SetupAddOrRemoveTestCertificate(NULL,NULL); if(Err != NO_ERROR) { SetupDebugPrint1(L"SETUP: SetupAddOrRemoveTestCertificate(NULL) failed. Error = %d \n", Err ); // // This is not considered a critial failure. // Err = NO_ERROR; } } // // Loop through all the lines in the ProductCatalogsToInstall section, // verifying and installing each one. // LineCount = SetupGetLineCount(SyssetupInf, SectionName); for(LineNo=0; LineNoInfCount)); i++) { if(!SetupQueryInfFileInformation(InfInfoBuffer, i, SyssetupInfName, SIZECHARS(SyssetupInfName), NULL)) { // // This should never fail! // MYASSERT(0); // // Just use syssetup.inf's simple name so there'll // be some clue as to what blew up. // lstrcpy(ProblemFile, L"syssetup.inf"); *Problem = SetupapiVerifyInfProblem; Err = GetLastError(); MYASSERT(Err != NO_ERROR); break; } Err = pSetupVerifyFile(NULL, DecompressedName, NULL, 0, pSetupGetFileTitle(SyssetupInfName), SyssetupInfName, Problem, ProblemFile, FALSE, NULL, NULL, NULL ); } if(Err != NO_ERROR) { // // Just return the error--the caller will deal with it. // if(*Problem == SetupapiVerifyCatalogProblem) { // // Use the catalog's original name, not our temporary // filename. // lstrcpy(ProblemFile, CatToInstall); } else { // // pSetupVerifyCatalogFile didn't know we were asking it to verify an // INF, but we do. // *Problem = SetupapiVerifyInfProblem; } DeleteFile(DecompressedName); goto clean0; } // // OK, catalog and INF both verify--now install the catalog. // Err = pSetupInstallCatalog(DecompressedName, InfFileName, NULL); if(Err != NO_ERROR) { // // Fill out problem information about the catalog we couldn't // install, and return this error to the caller. // *Problem = SetupapiVerifyCatalogProblem; lstrcpy(ProblemFile, CatToInstall); DeleteFile(DecompressedName); goto clean0; } } else { // // Just verify the catalog, and if it's OK, then install it. // (If we encounter any errors here, we'll log an event about it. // Err = pSetupVerifyCatalogFile(DecompressedName); if(Err == NO_ERROR) { Err = pSetupInstallCatalog(DecompressedName, InfFileName, NULL); if(Err != NO_ERROR) { ErrorMessageId = MSG_LOG_SYSSETUP_CATINSTALL_FAILED; } } else { ErrorMessageId = MSG_LOG_SYSSETUP_VERIFY_FAILED; } if(Err != NO_ERROR) { DWORD DontCare; SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, ErrorMessageId, CatToInstall, Err, NULL, SETUPLOG_USE_MESSAGEID, Err, NULL, NULL ); // // Also, add an entry about this failure to setupapi's PSS // exception logfile. // pSetupHandleFailedVerification(MainWindowHandle, SetupapiVerifyCatalogProblem, CatToInstall, DescriptionForError, pSetupGetCurrentDriverSigningPolicy(FALSE), TRUE, // no UI! Err, NULL, // log context NULL, // optional flags NULL ); if( !lstrcmpi(InfFileName, L"NT5.CAT") ){ //Special case NT5.CAT as critical failure *Problem = SetupapiVerifyCatalogProblem; //Otherwise just log it and move on lstrcpy(ProblemFile, CatToInstall); DeleteFile(DecompressedName); goto clean0; }else Err = NO_ERROR; } } // // Delete the temporary file we created to hold the decompressed // catalog during verification/installation. // DeleteFile(DecompressedName); } } clean0: if(!PrimaryCatalogProcessed) { // // Then we didn't find a line in our ProductCatalogsToInstall section // that was marked as the 'primary' catalog. Point the accusing finger // at syssetup.inf. // if(!SetupQueryInfFileInformation(InfInfoBuffer, 0, ProblemFile, MAX_PATH, NULL)) { // // This should never fail! // MYASSERT(0); // // Just use syssetup.inf's simple name so there'll be some clue as // to what blew up. // lstrcpy(ProblemFile, L"syssetup.inf"); } *Problem = SetupapiVerifyInfProblem; Err = ERROR_LINE_NOT_FOUND; } if(InfInfoBuffer) { MyFree(InfInfoBuffer); } return Err; } DWORD SetupInstallCatalog( IN LPCWSTR DecompressedName ) { PCWSTR InfFileName = pSetupGetFileTitle(DecompressedName); DWORD Err; UINT ErrorMessageId; Err = pSetupVerifyCatalogFile(DecompressedName); if(Err == NO_ERROR) { Err = pSetupInstallCatalog(DecompressedName, InfFileName, NULL); if(Err != NO_ERROR) { ErrorMessageId = MSG_LOG_SYSSETUP_CATINSTALL_FAILED; } } else { ErrorMessageId = MSG_LOG_SYSSETUP_VERIFY_FAILED; } if(Err != NO_ERROR) { SetuplogError(LogSevError, SETUPLOG_USE_MESSAGEID, ErrorMessageId, DecompressedName, Err, NULL, SETUPLOG_USE_MESSAGEID, Err, NULL, NULL ); } return Err; } VOID InitializeCodeSigningPolicies( IN BOOL ForGuiSetup ) /*++ Routine Description: Sets up the system-default policy values for driver and non-driver signing. These policies control what action is taken when a digital signature verification failure is encountered. The possible values are: Ignore (0) -- suppress any UI and continue with the operation (we do still log the error, however) Warn (1) -- warn the user, giving them the option of continuing in spite of the verification failure Block (2) -- inform the user of the failure, and do not allow them to continue with the operation The registry path for driver signing policy is: HKLM\Software\Microsoft\Driver Signing and the registry path for non-driver signing policy is: HKLM\Software\Microsoft\Non-Driver Signing In both cases, the value entry is called "Policy". For Win98 compatibility, this value is a REG_BINARY (length 1). However, when the codesigning stuff was first checked in on NT, it was implemented as a REG_DWORD. At that time, the default policy was ignore. We now want the default to be warn for both driver and non-driver signing during GUI-mode setup, while dropping the non-driver signing policy back to ignore once GUI-mode setup is completed. (If answerfile values are specified for either of these policies, those values are in effect for GUI-mode setup and thereafter.) When upgrading from previous builds (in the absence of answerfile entries), we want to preserve the existing policy settings once GUI-mode setup is completed. However, we'd like to raise the policy level to warn post-setup for upgrades from older builds (like beta 2). We use the aforementioned difference between the present REG_BINARY type and the old REG_DWORD type to accomplish this. If we retrieve the existing driver signing policy and its data type is REG_DWORD, then we update it to be set to warn (unless it's already set to block, in which case we leave it alone). Arguments: ForGuiSetup - if non-zero (TRUE), then we're entering GUI-mode setup, and we'll apply the answerfile policies, if provided. Otherwise, we'll use the same default values that are in-place post-setup. (Presently, this is Warn for driver signing, and Ignore for non-driver signing.) If zero (FALSE), we're leaving GUI-mode setup, and we want to restore the policies that were in effect when we entered setup. If there weren't any (i.e., a fresh install) then they were initialized to warn and ignore for driver and non-driver signing, respectively. See discussion above for how we raise driver signing policy from its old default of ignore to the present default of warn. Return Value: None --*/ { WCHAR p[MAX_PARAM_LEN]; BYTE SpDrvSignPolicy, SpNonDrvSignPolicy; LONG Err; if(ForGuiSetup) { // // Default in GUI-mode setup is that driver signing policy is set to // warn, and non-driver signing policy is set to ignore. // SpDrvSignPolicy = DRIVERSIGN_WARNING; SpNonDrvSignPolicy = DRIVERSIGN_NONE; // // Retrieve the (optional) system-default policy for driver signing. // if(SpSetupLoadParameter(pwDrvSignPol,p,MAX_PARAM_LEN)) { if(!lstrcmpi(p, pwIgnore)) { AFDrvSignPolicySpecified = TRUE; SpDrvSignPolicy = DRIVERSIGN_NONE; } else if(!lstrcmpi(p, pwWarn)) { AFDrvSignPolicySpecified = TRUE; SpDrvSignPolicy = DRIVERSIGN_WARNING; } else if(!lstrcmpi(p, pwBlock)) { AFDrvSignPolicySpecified = TRUE; SpDrvSignPolicy = DRIVERSIGN_BLOCKING; } } SetCodeSigningPolicy(PolicyTypeDriverSigning, SpDrvSignPolicy, (AFDrvSignPolicySpecified ? NULL : &DrvSignPolicy) ); // // Now retrieve the (optional) system-default policy for non-driver // signing. // if(SpSetupLoadParameter(pwNonDrvSignPol,p,MAX_PARAM_LEN)) { if(!lstrcmpi(p, pwIgnore)) { AFNonDrvSignPolicySpecified = TRUE; SpNonDrvSignPolicy = DRIVERSIGN_NONE; } else if(!lstrcmpi(p, pwWarn)) { AFNonDrvSignPolicySpecified = TRUE; SpNonDrvSignPolicy = DRIVERSIGN_WARNING; } else if(!lstrcmpi(p, pwBlock)) { AFNonDrvSignPolicySpecified = TRUE; SpNonDrvSignPolicy = DRIVERSIGN_BLOCKING; } } SetCodeSigningPolicy(PolicyTypeNonDriverSigning, SpNonDrvSignPolicy, (AFNonDrvSignPolicySpecified ? NULL : &NonDrvSignPolicy) ); } else { // // We're setting up the policies to be in effect after GUI-mode setup. // If the answer file specified a policy, then we'll leave that in // effect (i.e., it's applicable both during GUI-mode setup and // thereafter). // if(!AFDrvSignPolicySpecified) { SetCodeSigningPolicy(PolicyTypeDriverSigning, DrvSignPolicy, NULL); } if(!AFNonDrvSignPolicySpecified) { SetCodeSigningPolicy(PolicyTypeNonDriverSigning, NonDrvSignPolicy, NULL); } } } VOID InstallPrivateFiles( IN HWND Billboard ) /* Routine to make sure that files in delta.inf (winnt32 /m private files that live inside the cab) are copied to the driver cache directory so that setupapi finds them instead of the ones in the cab. */ { WCHAR DeltaPath[MAX_PATH]; HINF DeltaInf; HSPFILEQ FileQueue; PVOID QContext; BOOL b=TRUE; BYTE PrevPolicy; BOOL ResetPolicy = TRUE; // // Unless the default non-driver signing policy was overridden via an // answerfile entry, then we want to temporarily turn down the policy level // to ignore while we copy optional directories. Of course, setupapi log // entries will still be generated for any unsigned files copied during // this time, but there'll be no UI. // if(!AFNonDrvSignPolicySpecified) { SetCodeSigningPolicy(PolicyTypeNonDriverSigning, DRIVERSIGN_NONE, &PrevPolicy); ResetPolicy = TRUE; } BuildPathToInstallationFileEx (L"delta.inf", DeltaPath, MAX_PATH, FALSE); FileQueue = SetupOpenFileQueue(); b = b && (FileQueue != INVALID_HANDLE_VALUE); b = b && FileExists( DeltaPath, NULL ); if(b){ DeltaInf = SetupOpenInfFile(DeltaPath,NULL,INF_STYLE_WIN4,NULL); if(DeltaInf && (DeltaInf != INVALID_HANDLE_VALUE)) { SetupInstallFilesFromInfSection( DeltaInf, NULL, FileQueue, L"InstallSection", LegacySourcePath, SP_COPY_NEWER ); SetupCloseInfFile(DeltaInf); } else { b = FALSE; } } if( b ){ QContext = InitSysSetupQueueCallbackEx( Billboard, INVALID_HANDLE_VALUE, 0,0,NULL); if (QContext) { b = SetupCommitFileQueue( Billboard, FileQueue, SysSetupQueueCallback, QContext ); TermSysSetupQueueCallback(QContext); } else { b = FALSE; } } if(FileQueue != INVALID_HANDLE_VALUE) SetupCloseFileQueue(FileQueue); // // Now crank the non-driver signing policy back up to what it was prior to // entering this routine. // if(ResetPolicy) { SetCodeSigningPolicy(PolicyTypeNonDriverSigning, PrevPolicy, NULL); } return; } BOOL IsCatalogPresent( IN PCWSTR CatalogName ) { WCHAR FileBuffer[MAX_PATH]; ExpandEnvironmentStrings( L"%systemroot%", FileBuffer, sizeof(FileBuffer)/sizeof(WCHAR)); pSetupConcatenatePaths( FileBuffer, FILEUTIL_HORRIBLE_PATHNAME, MAX_PATH, NULL ); pSetupConcatenatePaths( FileBuffer, CatalogName, MAX_PATH, NULL ); return (FileExists( FileBuffer, NULL)); } BOOL CALLBACK CatalogListCallback( IN PCWSTR Directory OPTIONAL, IN PCWSTR FilePath ) /*++ Routine Description: This is the callback function for enumerating catalogs in a directory. Arguments: Directory - If not NULL or empty, it will be prepended to FilePath to build the file path FilePath - Path (including file name) to the file to verify Return value: TRUE if the file is a catalog, FALSE otherwise. --*/ { BOOL bRet = FALSE; PWSTR szPath = NULL; DWORD Error; if(NULL == FilePath || 0 == FilePath[0]) { goto exit; } if(Directory != NULL && Directory[0] != 0) { szPath = MyMalloc(MAX_PATH * sizeof(WCHAR)); if(NULL == szPath) { goto exit; } wcsncpy(szPath, Directory, MAX_PATH - 1); szPath[MAX_PATH - 1] = 0; if(!pSetupConcatenatePaths(szPath, FilePath, MAX_PATH, NULL)) { goto exit; } FilePath = szPath; } bRet = IsCatalogFile(INVALID_HANDLE_VALUE, (PWSTR) FilePath); exit: if(szPath != NULL) { MyFree(szPath); } return bRet; } DWORD DeleteOldCatalogs( VOID ) /*++ Routine Description: This routine deletes the catalogs specified by the ProductCatalogsToUninstall section of syssetup.inf. It does not delete any system catalogs (i.e. specified by the ProductCatalogsToInstall section of the same inf) since they will be installed after this function completes. Arguments: None. Return Value: If successful, the return value is NO_ERROR, otherwise it is a Win32 error code indicating the cause of the failure. --*/ { DWORD Error = NO_ERROR; HINF hInf = INVALID_HANDLE_VALUE; HCATADMIN hCatAdmin = NULL; PTSTR szCatPath = NULL; LIST_ENTRY InstalledCatalogsList; LONG lLines; LONG i; PCWSTR szInstallSection = L"ProductCatalogsToInstall"; PCWSTR szUninstallSection = L"ProductCatalogsToUninstall"; InitializeListHead(&InstalledCatalogsList); if(!CryptCATAdminAcquireContext(&hCatAdmin, &DriverVerifyGuid, 0)) { Error = GetLastError(); goto exit; } // // Uninstall exception package catalogs first; this could cleanup the list of installed catalogs a bit // SpUninstallExcepPackCatalogs(hCatAdmin); szCatPath = (PTSTR) MyMalloc(MAX_PATH * sizeof(TCHAR)); if(NULL == szCatPath) { Error = ERROR_NOT_ENOUGH_MEMORY; goto exit; } // // Build the list of installed catalogs // GetWindowsDirectory(szCatPath, MAX_PATH); if(!pSetupConcatenatePaths(szCatPath, FILEUTIL_HORRIBLE_PATHNAME, MAX_PATH, NULL)) { Error = ERROR_BAD_PATHNAME; goto exit; } Error = BuildFileListFromDir(szCatPath, NULL, 0, FILE_ATTRIBUTE_DIRECTORY, CatalogListCallback, &InstalledCatalogsList); if(Error != ERROR_SUCCESS) { goto exit; } // // Remove the system catalogs from the installed catalogs list since we don't want to delete them // hInf = SetupOpenInfFile(L"syssetup.inf", NULL, INF_STYLE_WIN4, NULL); if(INVALID_HANDLE_VALUE == hInf) { Error = GetLastError(); goto exit; } lLines = SetupGetLineCount(hInf, szInstallSection); for(i = 0; i < lLines; ++i) { INFCONTEXT ctx; PCWSTR szCatName; PSTRING_LIST_ENTRY pString; if(!SetupGetLineByIndex(hInf, szInstallSection, i, &ctx)) { Error = GetLastError(); goto exit; } szCatName = pSetupGetField(&ctx, 1); if(NULL == szCatName) { Error = GetLastError(); goto exit; } pString = SearchStringInList(&InstalledCatalogsList, szCatName, FALSE); if(pString != NULL) { RemoveEntryList(&pString->Entry); FreeStringEntry(&pString->Entry, TRUE); } } if(InstalledCatalogsList.Flink == &InstalledCatalogsList) { // // No catalogs left // goto exit; } // // Uninstall every catalog in the uninstall list // lLines = SetupGetLineCount(hInf, szUninstallSection); for(i = 0; i < lLines; ++i) { INFCONTEXT ctx; PCWSTR szCatName; PCWSTR szAttribName; PCWSTR szAttribValue; if(!SetupGetLineByIndex(hInf, szUninstallSection, i, &ctx)) { Error = GetLastError(); goto exit; } szCatName = pSetupGetField(&ctx, 1); if(NULL == szCatName) { Error = GetLastError(); goto exit; } szAttribName = pSetupGetField(&ctx, 2); szAttribValue = pSetupGetField(&ctx, 3); if(0 == szCatName[0]) { PLIST_ENTRY pEntry; // // If the name is not specified, an attribute or a value must be specified // if((NULL == szAttribName || 0 == szAttribName[0]) && (NULL == szAttribValue || 0 == szAttribValue[0])) { Error = ERROR_INVALID_DATA; goto exit; } // // Uninstall every catalog with the attribute name/value specified // pEntry = InstalledCatalogsList.Flink; while(pEntry != &InstalledCatalogsList) { // // Save Flink since SpUninstallCatalog might destroy pEntry // PLIST_ENTRY Flink = pEntry->Flink; PSTRING_LIST_ENTRY pString = CONTAINING_RECORD(pEntry, STRING_LIST_ENTRY, Entry); SpUninstallCatalog(hCatAdmin, pString->String, szCatPath, szAttribName, szAttribValue, &InstalledCatalogsList); pEntry = Flink; } } else { SpUninstallCatalog(hCatAdmin, szCatName, szCatPath, szAttribName, szAttribValue, &InstalledCatalogsList); } } exit: FreeStringList(&InstalledCatalogsList); if(szCatPath != NULL) { MyFree(szCatPath); } if(NULL != hCatAdmin) { CryptCATAdminReleaseContext(hCatAdmin, 0); } if(hInf != INVALID_HANDLE_VALUE) { SetupCloseInfFile(hInf); } return Error; } VOID GetDllCacheFolder( OUT LPWSTR CacheDir, IN DWORD cbCacheDir ) { DWORD retval; DWORD Type,Length; PWSTR RegData; if ((retval = QueryValueInHKLM( L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon", L"SFCDllCacheDir", &Type, (PVOID)&RegData, &Length)) != NO_ERROR) { ExpandEnvironmentStrings( L"%systemroot%\\system32\\dllcache", CacheDir, cbCacheDir ); } else { ExpandEnvironmentStrings( RegData, CacheDir, cbCacheDir ); MyFree(RegData); } } DWORD CleanOutDllCache( VOID ) /*++ Routine Description: This routine cleans out the current dllcache contents. Arguments: None. Return Value: Win32 error code indicating outcome. --*/ { DWORD retval = ERROR_SUCCESS, DeleteError = ERROR_SUCCESS; WIN32_FIND_DATA FindFileData; WCHAR CacheDir[MAX_PATH]; HANDLE hFind; PWSTR p; GetDllCacheFolder(CacheDir, MAX_PATH); MYASSERT(*CacheDir != L'\0'); pSetupConcatenatePaths( CacheDir, L"*", MAX_PATH, NULL ); // // save pointer to directory // p = wcsrchr( CacheDir, L'\\' ); if (!p) { ASSERT(FALSE); retval = ERROR_INVALID_DATA; goto exit; } p += 1; hFind = FindFirstFile( CacheDir, &FindFileData ); if (hFind == INVALID_HANDLE_VALUE) { retval = GetLastError(); goto exit; } do { if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { wcscpy( p, FindFileData.cFileName ); SetFileAttributes( CacheDir, FILE_ATTRIBUTE_NORMAL ); if (!DeleteFile( CacheDir )) { DeleteError = GetLastError(); } } } while(FindNextFile( hFind, &FindFileData )); FindClose( hFind ); retval = DeleteError; exit: return(retval); } DWORD PrepDllCache( VOID ) /*++ Routine Description: This routine prepares the dllcache for later on in setup. It cleans out the current dllcache contents and copies in a copy of the system catalog files. Arguments: None. Return Value: If successful, the return value is NO_ERROR, otherwise it is a Win32 error code indicating the cause of the failure. --*/ { DWORD retval = ERROR_SUCCESS; WCHAR CacheDir[MAX_PATH]; HANDLE h; USHORT Compression = COMPRESSION_FORMAT_DEFAULT; DWORD Attributes; BOOL b = FALSE; PWSTR RegData; DWORD Type,Length; HSPFILEQ hFileQ = INVALID_HANDLE_VALUE; PVOID Context; DWORD Count,i; if (MiniSetup) { retval = ERROR_SUCCESS; goto e0; } // // clean out old dllcache // CleanOutDllCache(); // // Configure the registry for the DllCache. // ConfigureSystemFileProtection(); // // get the path to the dllcache. // if ((retval = QueryValueInHKLM( L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon", L"SFCDllCacheDir", &Type, (PVOID)&RegData, &Length)) != NO_ERROR) { ExpandEnvironmentStrings( L"%systemroot%\\system32\\dllcache", CacheDir, MAX_PATH ); } else { ExpandEnvironmentStrings( RegData, CacheDir, MAX_PATH ); MyFree(RegData); } // // set attributes on dllcache (hidden, system, compressed...) // Attributes = GetFileAttributes(CacheDir); if (Attributes == 0xffffffff) { CreateDirectory( CacheDir, NULL ); Attributes = GetFileAttributes(CacheDir); } if (!(Attributes & FILE_ATTRIBUTE_COMPRESSED)) { Attributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM; SetFileAttributes( CacheDir, FILE_ATTRIBUTE_NORMAL ); h = CreateFile( CacheDir, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_SEQUENTIAL_SCAN, INVALID_HANDLE_VALUE ); if (h == INVALID_HANDLE_VALUE) { SetFileAttributes( CacheDir, Attributes ); retval = GetLastError(); goto e0; } DeviceIoControl( h, FSCTL_SET_COMPRESSION, &Compression, sizeof(Compression), NULL, 0, &retval, NULL ); CloseHandle( h ); SetFileAttributes( CacheDir, Attributes ); } // // copy system catalogs into the dllcache // MYASSERT( SyssetupInf != NULL ); hFileQ = SetupOpenFileQueue(); if (hFileQ == INVALID_HANDLE_VALUE) { retval = GetLastError(); goto e0; } Context = InitSysSetupQueueCallbackEx( MainWindowHandle, INVALID_HANDLE_VALUE, 0, 0, NULL); if (!Context) { retval = GetLastError(); goto e1; } Count = SetupGetLineCount( SyssetupInf, L"ProductCatalogsToInstall"); for (i = 0; i < Count; i++) { INFCONTEXT InfContext; WCHAR CatalogName[MAX_PATH]; BOOL SuccessfullyValidatedOrRestoredACatalog = FALSE; if(SetupGetLineByIndex( SyssetupInf, L"ProductCatalogsToInstall", i, &InfContext) && (SetupGetStringField( &InfContext, 1, CatalogName, sizeof(CatalogName)/sizeof(WCHAR), NULL))) { if (!SetupQueueCopy( hFileQ, DuDoesUpdatedFileExist (CatalogName) ? DuGetUpdatesPath () : LegacySourcePath, NULL, CatalogName, NULL, NULL, CacheDir, NULL, 0 )) { retval = GetLastError(); goto e2; } } } if (!SetupCommitFileQueue( MainWindowHandle, hFileQ, SysSetupQueueCallback, Context)) { retval = GetLastError(); goto e2; } retval = ERROR_SUCCESS; e2: TermSysSetupQueueCallback(Context); e1: SetupCloseFileQueue( hFileQ ); e0: return(retval); } DWORD SpUninstallCatalog( IN HCATADMIN CatAdminHandle OPTIONAL, IN PCWSTR CatFileName, IN PCWSTR CatFilePath OPTIONAL, IN PCWSTR AttributeName OPTIONAL, IN PCWSTR AttributeValue OPTIONAL, IN OUT PLIST_ENTRY InstalledCatalogsList OPTIONAL ) /*++ Routine Description: This function uninstalls the specified catalog based on a list of installed catalogs and a pair of attribute name/value. Arguments: CatAdminHandle - Handle to crypto context. If NULL, the function will open a context and close it upon exit. CatFileName - Name of the catalog (without any path) to be uninstalled. CatFilePath - If specified, specifies the path to CatFileName. AttributeName - See AttributeValue. AttributeValue - If AttributeName and AttributeValue are not specified, the catalog is always uninstalled. If AttributeName is specified and AttributeValue isn't, the catalog will be uninstalled only if it has an attribute with AttributeName name, regardess of its value. If AttributeName is not specified and AttributeValue is, the catalog will be uninstalled only if it has an attribute with AttributeValue value, regardless of its name. If both AttributeName and AttributeValue are specified, the catalog is uninstalled only if it has an attribute with AttributeName name and AttributeValue value. InstalledCatalogsList - If not NULL, contains the list of catalogs installed on the system. If the catalog is not on the list, it is not uninstalled. If the catalog is on the list, it is uninstalled and removed from the list. If NULL, the catalog is always uninstalled. Return value: NO_ERROR on success, otherwise a Win32 error code. --*/ { DWORD dwError = NO_ERROR; HCATADMIN hCatAdmin = CatAdminHandle; PSTRING_LIST_ENTRY pEntry = NULL; if(NULL == CatFileName || 0 == CatFileName[0]) { dwError = ERROR_INVALID_PARAMETER; goto exit; } if(NULL == CatAdminHandle && !CryptCATAdminAcquireContext(&hCatAdmin, &DriverVerifyGuid, 0)) { dwError = GetLastError(); goto exit; } if(NULL == InstalledCatalogsList || NULL != (pEntry = SearchStringInList(InstalledCatalogsList, CatFileName, FALSE))) { BOOL bFound; dwError = LookupCatalogAttribute(CatFileName, CatFilePath, AttributeName, AttributeValue, &bFound); if(dwError != ERROR_SUCCESS) { goto exit; } if(bFound) { if(CryptCATAdminRemoveCatalog(hCatAdmin, (PWCHAR) CatFileName, 0)) { if(pEntry != NULL) { RemoveEntryList(&pEntry->Entry); FreeStringEntry(&pEntry->Entry, TRUE); } } else { dwError = GetLastError(); SetuplogError( LogSevInformation, SETUPLOG_USE_MESSAGEID, MSG_LOG_SYSSETUP_CATALOG_NOT_DELETED, CatFileName, NULL, NULL ); } } } exit: if(NULL == CatAdminHandle && hCatAdmin != NULL) { CryptCATAdminReleaseContext(hCatAdmin, 0); } return dwError; } typedef struct _UNINSTALL_EXCEPPACK_CATALOG_CONTEXT { HCATADMIN CatAdminHandle; } UNINSTALL_EXCEPPACK_CATALOG_CONTEXT, * PUNINSTALL_EXCEPPACK_CATALOG_CONTEXT; BOOL CALLBACK SpUninstallExcepPackCatalogsCallback( IN const PSETUP_OS_COMPONENT_DATA SetupOsComponentData, IN const PSETUP_OS_EXCEPTION_DATA SetupOsExceptionData, IN OUT DWORD_PTR Context ) /*++ Routine Description: This is the callback function for the SetupEnumerateRegisteredOsComponents call in SpUninstallExcepPackCatalogs. It uninstalls the catalog specified by SetupOsExceptionData->CatalogFileName. Arguments: SetupOsComponentData - component data SetupOsExceptionData - exception pack data Context - pointer to an UNINSTALL_EXCEPPACK_CATALOG_CONTEXT struct Return value: TRUE to continue the enumeration --*/ { PUNINSTALL_EXCEPPACK_CATALOG_CONTEXT pContext; PCWSTR szCatName; ASSERT(Context != 0); pContext = (PUNINSTALL_EXCEPPACK_CATALOG_CONTEXT) Context; szCatName = wcsrchr(SetupOsExceptionData->CatalogFileName, L'\\'); ASSERT(szCatName != NULL); if(szCatName != NULL) { DWORD dwError = SpUninstallCatalog(pContext->CatAdminHandle, szCatName + 1, NULL, NULL, NULL, NULL); if(dwError != NO_ERROR) { SetupDebugPrint1(L"SETUP: SpUninstallCatalog returned 0x%08x.", dwError); } } return TRUE; } VOID SpUninstallExcepPackCatalogs( IN HCATADMIN CatAdminHandle OPTIONAL ) /*++ Routine Description: This function uninstalls all exception package catalogs. Arguments: CatAdminHandle - a handle to crypto catalog admin; may be NULL Return value: none --*/ { UNINSTALL_EXCEPPACK_CATALOG_CONTEXT Context; Context.CatAdminHandle = CatAdminHandle; SetupEnumerateRegisteredOsComponents(SpUninstallExcepPackCatalogsCallback, (DWORD_PTR) &Context); }