able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shell32/pifmgr.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3480 lines
118 KiB
C
Raw Blame History

/*
* Microsoft Confidential
* Copyright (C) Microsoft Corporation 1991
* All Rights Reserved.
*
*
* PIFMGR.C
* Main module for PIFMGR.DLL
*
* History:
* Created 31-Jul-1992 3:30pm by Jeff Parsons
*
* Exported Program Information File (PIF) Manager services:
*
* PifMgr_OpenProperties()
* Give it the name of an DOS application (com, exe, or bat),
* and it will open the PIF associated with that application
* and return a "handle" to the app's "properties". Use this
* handle when calling any of the other "properties" services (ie,
* Get, Set, and Close).
*
* If no PIF exists, it will still allocate a PIF data block
* in memory and initialize it, either with data from _DEFAULT.PIF
* or its internal defaults. It will also construct the PIF name
* it was looking for but couldn')t find and save that in its internal
* PIF data structure, so that if PifMgr_SetProperties is ever called, the
* data can be saved to disk.
*
* PifMgr_GetProperties()
* Returns the specified block of data from the associated PIF.
* If it is a "named" block, it must be the name of a linked
* extension inside the PIF, which can be any predefined name
* (eg, "WINDOWS 386 3.0") or the name of your own block. You can
* create your own named data blocks using the PifMgr_SetProperties()
* service. "Named" data can also be thought of as "raw" data,
* because it is returned to the caller as-is -- without translation.
*
* The size of a named block can be determined by calling
* PifMgr_GetProperties with a size of zero; no data is copied, but the size
* of the requested block is returned (0 if not found).
*
* All named blocks can be enumerated by passing NULL for the name,
* a pointer to a 16-byte buffer for the requested block name, and a
* 0-based block index in the size parameter. The size returned
* is the size of the block (0 if none).
*
* If an unnamed property block is requested (ie, the selector of
* the name parameter is NULL, and the offset is a property group
* ordinal), then the associated structure is returned. For example,
* PifMgr_GetProperties(GROUP_TSK) returns a predefined structure (see
* PROPTSK in PIF.H) containing all the tasking-related information,
* in a format that is PIF-independent. This is a valuable service,
* because it relieves callers from having to cope with PIFs
* containing a wide variety of sections (known as PIF extensions),
* only one of which is required. Think of this as "cooked" data.
*
* A third variation is raw read/write of the entire PIF data block,
* if lpszGroup is NULL. This must be used with extreme caution, and
* will only be allowed if the properties were opened with the
* OPENPROPS_RAWIO flag specified.
*
* PifMgr_SetProperties()
* This is pretty much the opposite of PifMgr_GetProperties, except that it
* also takes a flags parameter that can specify that the changes
* be made immediately, or deferred to PifMgr_CloseProperties.
*
* PifMgr_CloseProperties()
* Flushes any dirty PIF data in memory, and frees the local heap
* storage.
*
*/
#include "shellprv.h"
#pragma hdrstop
/* Global R/W DLL data
*/
PPROPLINK g_pplHead; // pointer to first prop entry
HANDLE g_offHighestPropLink; // highest offset of a prop thus far recorded
TCHAR g_szNone[16]; // initialized by LibMainP,
TCHAR g_szAuto[16]; // and 16 chars to allow for localization
char g_szMSDOSSTSFile[] = "C:\\MSDOSSYS.STS";
TCHAR g_szConfigFile[] = TEXT("C:") CONFIGFILE;
TCHAR g_szAutoexecFile[] = TEXT("C:") AUTOEXECFILE;
TCHAR g_szMConfigFile[] = TEXT("C:") MCONFIGFILE;
TCHAR g_szMAutoexecFile[] = TEXT("C:") MAUTOEXECFILE;
TCHAR g_szWConfigFile[] = TEXT("C:") WCONFIGFILE;
TCHAR g_szWAutoexecFile[] = TEXT("C:") WAUTOEXECFILE;
#ifdef DBCS
char ImeBatchFile[] = "DOSIME\0";
#endif
#define NT_CONFIG_FILE "%SystemRoot%\\SYSTEM32\\CONFIG.NT"
#define NT_AUTOEXEC_FILE "%SystemRoot%\\SYSTEM32\\AUTOEXEC.NT"
#define LPPH_OFF(off) ((LPBYTE)lpph + off)
#define LPPIF_FIELDOFF(off) ((LPBYTE)ppl->lpPIFData + FIELD_OFFSET(PIFDATA,off))
#define LPPIF_OFF(off) ((LPBYTE)ppl->lpPIFData + off)
//
// g_szDefaultPIF can be in one of three states:
//
// 1. "_DEFAULT.PIF", which means that we have never needed to search
// for a _default.pif yet. The next time we need to locate
// _default.pif, we must perform a full search. On success,
// move to state 2. On failure, move to state 3.
//
// 2. A fully-qualified path to _default.pif, which means that we have
// searched for a _default.pif and found it in the specified
// location. The next time we need to locate _default.pif, we
// will look here. If found, remain in state 2, else move to
// state 3.
//
// 3. The null string, which means that we searched for a _default.pif
// and didn't find one. The next time we need to locate
// _default.pif, we just fail without even looking on the disk.
// (This is the common case for a clean install.)
//
// Note that all the cases are "sticky"; once you reach a state, you
// can never move back to a previous state. This sacrifices flexibility
// for performance.
//
// The macro fTryDefaultPif() returns nonzero if we are in cases
// 1 or 2.
//
// The macro fDefaultPifFound() returns nonzero if we are in case 2.
//
// WARNING! WARNING! WARNING! WARNING!
//
// Evil hack relies on the fact that the three states can be
// distinguished by the first character of g_szDefaultPIF, which
// in turn relies on the fact that `_' cannot be the first character
// of a fully-qualified path. (It is not a valid drive letter,
// and it cannot start a UNC.)
//
//
#define INIT_INIDATA 0x01
#define INIT_PIFDIR 0x02
CHAR fbInit = 0; // see INIT_* flags
INT iPIFName = (12*sizeof(TCHAR)); // strlen(g_szPIFDir)
INT iWinName = (12*sizeof(TCHAR)); // strlen(g_szPIFDir)
TCHAR g_szPIFDir[MAXPATHNAME] = TEXT("\\WINDOWS\\PIF");
TCHAR g_szDefaultPIF[MAXPATHNAME] = TEXT("_DEFAULT.PIF");
#define fTryDefaultPif() g_szDefaultPIF[0]
#define fDefaultPifFound() (g_szDefaultPIF[0] != TEXT('_'))
//
// szComspec is the name of the COMSPEC program, usually "COMMAND.COM"
// or "CMD.EXE".
//
TCHAR szComspec[8+1+3+1];
/* Global R/O DLL data
*/
extern const TCHAR c_szNULL[]; // A string so nice...
const TCHAR szZero[] = TEXT("0");
const int acbData[] = {
sizeof(PROPPRG),
sizeof(PROPTSK),
sizeof(PROPVID),
sizeof(PROPMEM),
sizeof(PROPKBD),
sizeof(PROPMSE),
sizeof(PROPSND),
sizeof(PROPFNT),
sizeof(PROPWIN),
sizeof(PROPENV),
sizeof(PROPNT31),
sizeof(PROPNT40),
};
/*
* The casts are used because we intentionally mis-prototyped the GetXxxData
* and SetXxxData functions to receive their third argument as a LPXXX instead
* of a LPVOID.
*/
const DATAGETFN afnGetData[] = {
(DATAGETFN)GetPrgData,
(DATAGETFN)GetTskData,
(DATAGETFN)GetVidData,
(DATAGETFN)GetMemData,
(DATAGETFN)GetKbdData,
(DATAGETFN)GetMseData,
(DATAGETFN)GetSndData,
(DATAGETFN)GetFntData,
(DATAGETFN)GetWinData,
(DATAGETFN)GetEnvData,
(DATAGETFN)GetNt31Data,
(DATAGETFN)GetNt40Data,
};
const DATASETFN afnSetData[] = {
(DATASETFN)SetPrgData,
(DATASETFN)SetTskData,
(DATASETFN)SetVidData,
(DATASETFN)SetMemData,
(DATASETFN)SetKbdData,
(DATASETFN)SetMseData,
(DATASETFN)SetSndData,
(DATASETFN)SetFntData,
(DATASETFN)SetWinData,
(DATASETFN)SetEnvData,
(DATASETFN)SetNt31Data,
(DATASETFN)SetNt40Data,
};
// WIN.INI things of interest
// Note: some of these NEED to be ANSI strings, and other TCHAR
// strings. Please do not arbitrarily change the type casts of
// these strings!!!! (RickTu)
const TCHAR szMemory[] = TEXT("MEMORY");
const TCHAR szComp[] = TEXT("COMPATIBLE");
CHAR szSingle[] = "DOS=SINGLE\r\n";
CHAR szCRLF[] = "\r\n";
CHAR szEcho[] = "ECHO ";
CHAR szPause[] = "\r\nPAUSE\r\n";
CHAR szCall[] = "CALL ";
CHAR szCD[] = "CD ";
CHAR szWin[] = "WIN";
// SYSTEM.INI things of interest
const TCHAR szSystemINI[] = TEXT("SYSTEM.INI");
const TCHAR sz386EnhSection[] = TEXT("386Enh");
const TCHAR szWOAFontKey[] = TEXT("WOAFont");
const TCHAR szWOADBCSFontKey[] = TEXT("WOADBCSFont");
const TCHAR szNonWinSection[] = TEXT("NonWindowsApp");
const TCHAR szTTInitialSizes[] = TEXT("TTInitialSizes");
#ifdef CUSTOMIZABLE_HEURISTICS
const TCHAR szTTHeuristics[] = TEXT("TTHeuristics");
const TCHAR szTTNonAspectMin[] = TEXT("TTNonAspectMin");
#endif
TCHAR szTTCacheSection[2][32] = {TEXT("TTFontDimenCache"), TEXT("TTFontDimenCacheDBCS")};
//
// These are because they are accessed only when we need to create
// a new PIF file or convert a 3.1 PIF file into a 4.0 PIF file.
//
const TCHAR szDOSAPPINI[] = TEXT("DOSAPP.INI");
const TCHAR szDOSAPPSection[] = TEXT("DOS Applications");
const TCHAR szDOSAPPDefault[] = TEXT("Default");
const TCHAR szDisplay[] = TEXT("DISPLAY");
const TCHAR szDefIconFile[] = ICONFILE_DEFAULT;
const TCHAR szDotExe[] = TEXT(".EXE");
const TCHAR szDotCom[] = TEXT(".COM");
const TCHAR szDotBat[] = TEXT(".BAT");
const TCHAR szDotPif[] = TEXT(".PIF");
const TCHAR szDotCmd[] = TEXT(".CMD");
const TCHAR * apszAppType[] = {
szDotExe, szDotCom, szDotBat, szDotCmd, szDotPif
};
CHAR szSTDHDRSIG[] = STDHDRSIG;
CHAR szW286HDRSIG30[] = W286HDRSIG30;
CHAR szW386HDRSIG30[] = W386HDRSIG30;
CHAR szWENHHDRSIG40[] = WENHHDRSIG40;
CHAR szWNTHDRSIG31[] = WNTHDRSIG31;
CHAR szWNTHDRSIG40[] = WNTHDRSIG40;
CHAR szCONFIGHDRSIG40[] = CONFIGHDRSIG40;
CHAR szAUTOEXECHDRSIG40[] = AUTOEXECHDRSIG40;
const TCHAR szRunOnceKey[] = REGSTR_PATH_RUNONCE;
const TCHAR szPIFConvert[] = TEXT("PIFConvert");
const TCHAR szPIFConvertExe[] = TEXT("RUNDLL.EXE PIFMGR.DLL,ProcessStartupProperties");
const TCHAR szPIFConvertKey[] = REGSTR_PATH_PIFCONVERT;
const TCHAR szMSDOSMode[] = REGSTR_VAL_MSDOSMODE;
const TCHAR szMSDOSModeDiscard[] = REGSTR_VAL_MSDOSMODEDISCARD;
// wsprintf formatting strings
const TCHAR szDotPercent03d[] = TEXT(".%03d");
// miscellaneous hack-o-ramas
const TCHAR szPP4[] = TEXT("PP4"); // MS Powerpoint 4.0
PROPTSK tskDefault ={TSK_DEFAULT,
TSKINIT_DEFAULT,
TSKFGNDBOOST_DEFAULT,
TSKBGNDBOOST_DEFAULT,
0,
0,
TSKIDLESENS_DEFAULT,
};
PROPVID vidDefault ={VID_DEFAULT,
VIDINIT_DEFAULT,
0,
0,
0,
};
PROPMEM memDefault ={MEM_DEFAULT,
MEMINIT_DEFAULT,
MEMLOW_DEFAULT, // ignore stdpifdata.minmem?
MEMLOW_MAX, // ignore stdpifdata.maxmem?
MEMEMS_DEFAULT,
MEMEMS_MAX,
MEMXMS_DEFAULT,
MEMXMS_MAX,
};
PROPKBD kbdDefault ={KBD_DEFAULT,
KBDINIT_DEFAULT,
KBDALTDELAY_DEFAULT,
KBDALTPASTEDELAY_DEFAULT,
KBDPASTEDELAY_DEFAULT,
KBDPASTEFULLDELAY_DEFAULT,
KBDPASTETIMEOUT_DEFAULT,
KBDPASTESKIP_DEFAULT,
KBDPASTECRSKIP_DEFAULT,
};
PROPMSE mseDefault ={MSE_DEFAULT,
MSEINIT_DEFAULT,
};
PROPENV envDefault ={ENV_DEFAULT,
ENVINIT_DEFAULT,
"",
ENVSIZE_DEFAULT,
ENVDPMI_DEFAULT,
};
WORD flWinDefault = WIN_DEFAULT;
/*
* Default face name to use for Raster fonts. Currently, this is
* just a hard-coded value (ie, not maintained in any INI file).
*/
CHAR szRasterFaceName[LF_FACESIZE] = "Terminal";
/*
* Default face name to use for TrueType fonts. It must be a monospace
* font, and it must be a font that everyone is guaranteed to have. Currently,
* this can be changed by setting TTFont in [NonWindowsApp] in SYSTEM.INI.
*/
// now this is initialized with string resource. The 2nd element will get
// the native typeface for the bilingual dos prompt
CHAR szTTFaceName[2][LF_FACESIZE] = {"Lucida Console", "Courier New"};
const TCHAR szAltKeyDelay [] = TEXT("AltKeyDelay");
const TCHAR szAltPasteDelay [] = TEXT("AltPasteDelay");
const TCHAR szKeyPasteDelay [] = TEXT("KeyPasteDelay");
const TCHAR szKeyBufferDelay [] = TEXT("KeyBufferDelay");
const TCHAR szKeyPasteTimeout [] = TEXT("KeyPasteTimeout");
const TCHAR szKeyPasteSkipCount [] = TEXT("KeyPasteSkipCount");
const TCHAR szKeyPasteCRSkipCount[] = TEXT("KeyPasteCRSkipCount");
const TCHAR szMouseInDosBox [] = TEXT("MouseInDosBox");
const TCHAR szDisablePositionSave[] = TEXT("DisablePositionSave");
const TCHAR szDOSPromptExitInst [] = TEXT("DOSPromptExitInstruc");
const TCHAR szCommandEnvSize [] = TEXT("CommandEnvSize");
const TCHAR szScreenLines [] = TEXT("ScreenLines");
const INIDATA aINIData[] = {
{sz386EnhSection, szAltKeyDelay, &kbdDefault.msAltDelay, INIDATA_FIXEDPOINT},
{sz386EnhSection, szAltPasteDelay, &kbdDefault.msAltPasteDelay, INIDATA_FIXEDPOINT},
{sz386EnhSection, szKeyPasteDelay, &kbdDefault.msPasteDelay, INIDATA_FIXEDPOINT},
{sz386EnhSection, szKeyBufferDelay, &kbdDefault.msPasteFullDelay,INIDATA_FIXEDPOINT},
{sz386EnhSection, szKeyPasteTimeout, &kbdDefault.msPasteTimeout, INIDATA_FIXEDPOINT},
{sz386EnhSection, szKeyPasteSkipCount, &kbdDefault.cPasteSkip, INIDATA_DECINT},
{sz386EnhSection, szKeyPasteCRSkipCount, &kbdDefault.cPasteCRSkip, INIDATA_DECINT},
{szNonWinSection, szMouseInDosBox, &mseDefault.flMse, INIDATA_BOOLEAN, MSE_WINDOWENABLE},
{szNonWinSection, szDisablePositionSave, &flWinDefault, INIDATA_BOOLEAN | INIDATA_INVERT, WIN_SAVESETTINGS},
#ifdef ENVINIT_INSTRUCTIONS
{sz386EnhSection, szDOSPromptExitInst, &envDefault.flEnvInit, INIDATA_BOOLEAN, ENVINIT_INSTRUCTIONS},
#endif
{szNonWinSection, szCommandEnvSize, &envDefault.cbEnvironment, INIDATA_DECINT},
{szNonWinSection, szScreenLines, &vidDefault.cScreenLines, INIDATA_DECINT},
};
/**************************************************************************
*
* OVERVIEW OF INI FILE USAGE
*
*
* SYSTEM.INI
*
* [386Enh]
*
* WOAFont=<fon filename>
*
* Status: Public
* Default: dosapp.fon
* Purpose:
*
* This setting allows the user to specify which Terminal font
* file should be loaded when DOS box is started.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
*
* [NonWindowsApp]
*
* DisablePositionSave=<Boolean>
*
* Status: Public
* Default: 0 (FALSE)
* Purpose:
*
* When FALSE, the position and font used in a non-Windows
* application is saved in the application's PIF file when
* you exit the application. When TRUE, the position, fonts, and
* toolbar state of a non-Windows application whose settings
* have not been previously saved in the DOSAPP.INI file will
* not be saved.
*
* If enabled, the setting can be overridden for each
* non-Windows application by selecting the Save Settings On
* Exit check box in the Font dialog box.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
* Compatibility notes:
*
* In Windows 3.x, the "position save" (and font) information was
* saved in DOSAPP.INI, and although we will still read DOSAPP.INI
* in the absence of any information in the PIF file, we only *write*
* settings back to the PIF file. DOSAPP.INI should be considered
* obsolete.
*
*
* TTFont=<fontname>
*
* Status: ?
* Default: Courier New // FEATURE -- this should be a TT OEM font
* Purpose:
*
* This setting allows the user to specify which TrueType font
* will be used in a DOS box. It must be an OEM font.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
*
* TTInitialSizes=<i1 i2 i3 i4 ... i16>
*
* Status: ?
* Default: 4 5 6 7 8 9 10 11 12 14 16 18 20 22 36 72
* Purpose:
*
* This setting allows the user to specify which font sizes
* WinOldAp initially builds for the TrueType fonts in a DOS
* application window.
*
* At most 16 font sizes can be requested.
*
* Note that this INI entry is consulted only the first time
* Windows is restarted after changing video drivers or fonts.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
*
* TTHeuristics=<i1 i2 i3 i4 i5 i6 i7 i8 i9>
*
* Status: Public
* Default: 5000 1000 0 1000 5000 1000 0 1000 1
* Purpose:
*
* These integers control the way Windows chooses the font to
* display for DOS applications running inside a window if you
* have chosen "Auto" as the font size.
*
* The parameters are named as follows:
*
* i1=XOvershootInitial
* i2=XOvershootScale
* i3=XShortfallInitial
* i4=XShortfallScale
* i5=YOvershootInitial
* i6=YOvershootScale
* i7=YShortfallInitial
* i8=YShortfallScale
* i9=TrueTypePenalty
*
* Each penalty value may not exceed 5000.
*
* When Windows needs to select a font for use in a DOS
* application's window, it goes through the list of font
* sizes available and computes the "penalty" associated
* with using that font. Windows then selects the font with
* the smallest penalty.
*
* The horizontal penalty is computed as follows:
*
* Let dxActual = <actual window width>
* Let dxDesired = <font width> * <characters per line>
*
* If dxActual = dxDesired:
* xPenalty = 0
* If dxActual < dxDesired:
* Let Ratio = 1 - dxDesired / dxActual
* xPenalty = XOvershootInitial + Ratio * XOvershootScale
* If dxActual > dxDesired:
* Let Ratio = 1 - dxActual / dxDesired
* xPenalty = XShortfallInitial + Ratio * XShortfallScale
*
* The vertical penalty is computed similarly.
*
* Note that the Ratio is always a fraction between 0 and 1.
*
* The penalty associated with a font is the sum of the vertical
* and horizontal penalties, plus the TrueTypePenalty if the font
* is a TrueType font.
*
* The default value of 1 for the TrueTypePenalty means that,
* all other things being equal, Windows will select a raster
* font in preference to a TrueType font. You can set this
* value to -1 if you wish the opposite preference.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
* Internals:
*
* Even though floating point appears in the computations,
* everything is really done in integer arithmetic.
*
* Pixels are NEVER MENTIONED anywhere in the penalty computations.
* (All pixel values are divided by other pixel values, so that
* we get a dimensionless number as a result.)
* This keeps us independent of the display resolution as well
* as the display aspect ratio.
*
* Since the stretch and shrink are taken as fractions of the
* larger dimension, this keeps us from penalizing large
* differences by too much. This is important because there
* isn't much visible difference between being ten times too
* big and being eleven times too big, but there is a big
* difference between being just right and being twice as big.
*
* We must be careful not to let the maximum possible penalty
* exceed 32767. This is done by making sure that each
* dimension cannot produce a penalty of greater than 10000
* (5000+5000), and that the TrueTypePenalty is at most 5000.
* This makes the maximum possible penalty 25000.
* This range checking is done by FontSelInit.
*
*
* TTNonAspectMin=<x y>
*
* Status: Public
* Default: 3 3
* Purpose:
*
* These integers control the minimum width and height font that
* Windows will attempt to create automatically in response to a
* resize operation when TrueType fonts in DOS boxes are enabled
* and the "Auto" font size is selected.
*
* These values prevent Windows from creating visually useless
* fonts like 10 x 1 or 1 x 10. The default values prevent Windows
* from trying to create X x Y fonts if X < 3 or Y < 3.
*
* TTNonAspectMin is not consulted if the font is being created at
* its default aspect ratio. In other words, Windows will create,
* for example, a 1 x 3 font, if 1 x 3 is the standard aspect ratio
* for a 3-pixel-high font.
*
* To permit all aspect ratios, set the values to "0 0".
*
* To forbid all aspect ratios except for the standard aspect ratio,
* set the values to "-1 -1".
*
* [TTFontDimenCache]
*
* dxWidthRequested dyHeightRequested=dxWidthActual dyWidthActual
*
* Status: Private
* Default: Null
* Purpose:
*
* The [FontDimenCache] section contains information about
* TrueType font sizes that have been created. Each entry
* has as the keyname the width and height that were passed
* to CreateFont and has as the value the width and height of
* the font that was actually created.
*
* Internals:
*
* Inspected by AddTrueTypeFontsToFontList.
* Set by AddOneNewTrueTypeFontToFontList.
*
*
**************************************************************************
*
* DOSAPP.INI (obsolete, supported on a read-only basis)
*
* [Dos Applications]
*
* C:\FULL\PATH\TO\EXE\COM\BAT\OR.PIF=<wFlags wFontWidth wFontHeight
* wWinWidth wWinHeight length flags showCmd ptMinPositionX
* ptMinPositionY ptMaxPositionX ptMaxPositionY
* rcNormalLeft rcNormalTop rcNormalRight rcNormalBottom>
*
* Status: Private
* Purpose:
*
* These values are used to restore a DOS application's window
* to the state it was in when the DOS app last exited normally.
*
* The values are taken directly from the INIINFO structure, qv.
*
* The values of ptMinPositionX and ptMinPositionY are always -1,
* since we do not try to preserve the icon position.
*
* If wFontHeight has the high bit set, then the font that
* should be used is a TrueType font.
*
* If wFontWidth = 1 and wFontHeight = -1, then
* Auto-font-selection is active.
*
* Compatibility notes:
*
* In Windows 3.x, the "position save" (and font) information was
* saved in DOSAPP.INI, and although we will still read DOSAPP.INI
* in the absence of any information in the PIF file, we only *write*
* settings back to the PIF file. DOSAPP.INI should be considered
* obsolete.
*
*
**************************************************************************
*
* THE NEXT INI VAR IS NOT IMPLEMENTED BUT SHOULD BE
*
**************************************************************************
*
* SYSTEM.INI
*
* [NonWindowsApp]
*
* TTFontTolerance=<i>
*
* Status: Public
* Default: 200
* Purpose:
*
* This setting indicates how large a penalty (see TTHeuristics)
* Windows should tolerate before trying to synthesize new font
* sizes from TrueType fonts.
*
* Decreasing this value will result in a tighter fit of the
* Windows-selected font to the actual window size, but at a
* cost in speed and memory.
*
* To change:
*
* Use Notepad to edit the SYSTEM.INI file.
*
*
* Internals:
*
* Inspected by ChooseBestFont, if implemented.
*
**************************************************************************/
void PifMgrDLL_Init()
{
static BOOL fInit = FALSE;
if (!fInit)
{
LoadString(g_hinst, IDS_PIF_NONE, g_szNone, ARRAYSIZE(g_szNone));
LoadString(g_hinst, IDS_AUTONORMAL, g_szAuto, ARRAYSIZE(g_szAuto));
LoadGlobalFontData();
fInit = TRUE;
}
}
void PifMgrDLL_Term()
{
FreeGlobalFontData();
}
/** GetPIFDir - Form default PIF directory name + name of given file
*
* INPUT
* None
*
* OUTPUT
* None
*/
void GetPIFDir(LPTSTR pszName)
{
int i;
static const TCHAR szBackslashPIF[] = TEXT("\\PIF");
FunctionName(GetPIFDir);
if (!(fbInit & INIT_PIFDIR)) {
// Set up g_szPIFDir, less space for a filename, less space for \PIF
i = ARRAYSIZE(g_szPIFDir)-lstrlen(pszName)-ARRAYSIZE(szBackslashPIF);
if (i <= 0) // sanity check
return;
GetWindowsDirectory(g_szPIFDir, i);
iPIFName = lstrlen(g_szPIFDir);
if (StrRChr(g_szPIFDir, NULL, TEXT('\\')) == &g_szPIFDir[iPIFName-1])
iPIFName--;
iWinName = iPIFName;
lstrcpy(g_szPIFDir+iPIFName, szBackslashPIF);
iPIFName += ARRAYSIZE(szBackslashPIF)-1;
i = (int)GetFileAttributes(g_szPIFDir);
if (i == -1) {
// It didn't exist, so try to create it (returns TRUE if success)
i = CreateDirectory(g_szPIFDir, NULL);
if (i)
SetFileAttributes(g_szPIFDir, FILE_ATTRIBUTE_HIDDEN);
}
else if (i & FILE_ATTRIBUTE_DIRECTORY)
i = TRUE; // directory already exists, cool!
else
i = FALSE; // some sort of file is in the way...
if (i) {
g_szPIFDir[iPIFName++] = TEXT('\\'); // append the slash we'll need
// to separate future filenames (the
// space after is already zero-init'ed)
}
else // we'll just have to use the Windows dir
iPIFName -= ARRAYSIZE(szBackslashPIF)-2;
fbInit |= INIT_PIFDIR;
}
// Now initialize g_szPIFDir with the name of the file we're processing
if (pszName)
lstrcpyn(g_szPIFDir+iPIFName, pszName, ARRAYSIZE(g_szPIFDir)-iPIFName);
}
/** GetINIData - Read WIN.INI/SYSTEM.INI/DOSAPP.INI for default settings
*
* INPUT
* Nothing
*
* OUTPUT
* Nothing; global defaults (re)set
*
* NOTES
* We only do this work now if GetPIFData couldn't open a PIF file, or
* could but it contained no enhanced section. And we never do it more than
* once per fresh load of this DLL.
*/
void GetINIData()
{
int t;
const INIDATA *pid;
LPCTSTR lpsz;
DWORD dwRet;
TCHAR szTemp[MAX_PATH];
FunctionName(GetINIData);
if (fbInit & INIT_INIDATA) // if already done
return; // then go away
for (pid=aINIData; pid-aINIData < ARRAYSIZE(aINIData); pid++) {
t = *(INT UNALIGNED *)pid->pValue;
if (pid->iFlags & (INIDATA_DECINT | INIDATA_BOOLEAN)) {
if (pid->iFlags & INIDATA_BOOLEAN) {
t &= pid->iMask;
if (pid->iFlags & INIDATA_INVERT)
t ^= pid->iMask;
}
t = GetPrivateProfileInt(pid->pszSection,
pid->pszKey,
t,
szSystemINI);
if (pid->iFlags & INIDATA_BOOLEAN) {
if (t)
t = pid->iMask;
if (pid->iFlags & INIDATA_INVERT)
t ^= pid->iMask;
t |= *(INT UNALIGNED *)pid->pValue & ~pid->iMask;
}
*(INT UNALIGNED *)pid->pValue = t;
}
else
if (pid->iFlags & INIDATA_FIXEDPOINT) {
wsprintf(szTemp, szDotPercent03d, t);
GetPrivateProfileString(pid->pszSection,
pid->pszKey,
szTemp,
szTemp,
ARRAYSIZE(szTemp),
szSystemINI);
*(INT UNALIGNED *)pid->pValue = StrToInt(szTemp+1);
}
else
ASSERTFAIL();
}
//
// Locate COMSPEC once and for all.
//
dwRet = GetEnvironmentVariable(TEXT("COMSPEC"), szTemp, ARRAYSIZE(szTemp));
if (dwRet < ARRAYSIZE(szTemp) && dwRet > 0)
{
lpsz = StrRChr(szTemp, NULL, TEXT('\\'));
if (lpsz) {
lstrcpyn(szComspec, lpsz+1, ARRAYSIZE(szComspec));
}
}
fbInit |= INIT_INIDATA;
}
/** InitProperties - initialize new property structure
*
* INPUT
* ppl -> property
* fLocked == TRUE to return data locked, FALSE unlocked
*
* OUTPUT
* Nothing (if successful, ppl->hPIFData will become non-zero)
*/
void InitProperties(PPROPLINK ppl, BOOL fLocked)
{
LPSTDPIF lpstd;
LPW386PIF30 lp386 = NULL;
CHAR achPathName[ARRAYSIZE(ppl->szPathName)];
BYTE behavior = 0;
FunctionName(InitProperties);
GetINIData(); // make sure we have all the right defaults
if (ResizePIFData(ppl, sizeof(STDPIF)) != -1) {
// We're no longer called *only* after a fresh ZERO'd HeapAlloc
// by ResizePIFData. We could be getting called because PifMgr_OpenProperties
// was told to punt on an ambiguous PIF and create new settings.
// Hence, we always zero-init the buffer ourselves now.
BZero(ppl->lpPIFData, ppl->cbPIFData);
lpstd = (LPSTDPIF)ppl->lpPIFData;
lpstd->id = 0x78;
PifMgr_WCtoMBPath( ppl->szPathName, achPathName, ARRAYSIZE(achPathName) );
lstrcpyncharA(lpstd->appname, achPathName+ppl->iFileName, ARRAYSIZE(lpstd->appname), '.');
CharToOemA(lpstd->appname, lpstd->appname);
// NOTE: When 3.x Setup creates PIF files, it sets maxmem to 640;
// that's typically what memDefault.wMaxLow will be too....
lpstd->minmem = memDefault.wMinLow;
lpstd->maxmem = (WORD) GetProfileInt(apszAppType[APPTYPE_PIF]+1, szMemory, memDefault.wMaxLow);
lstrcpynA(lpstd->startfile, achPathName, ARRAYSIZE(lpstd->startfile));
CharToOemA(lpstd->startfile, lpstd->startfile);
//
// New for 4.0: fDestroy (close on exit) is disabled by default
// for most apps, but is enabled by default for COMSPEC.
//
lpstd->MSflags = 0;
if (!lstrcmpi(ppl->szPathName+ppl->iFileName, szComspec)) {
lpstd->MSflags = fDestroy;
}
// Initialize various goofy non-zero stuff just to make it
// look like a backward-compatible PIF file -- not that we use
// or particularly care about any of it
// NOTE: When 3.x Setup creates PIF files, it sets screen to 0x7F
lpstd->cPages = 1;
lpstd->highVector = 0xFF;
lpstd->rows = 25;
lpstd->cols = 80;
lpstd->sysmem = 0x0007;
// fFullScreen is no longer default, so only if an explicit
// COMPATIBLE=FALSE exists in the PIF section of WIN.INI will
// we set fScreen in behavior and fFullScreen in PfW386Flags
// Similarly, fDestroy is no longer default, but we'll go
// back to the old way if the switch tells us to.
if (!GetProfileInt(apszAppType[APPTYPE_PIF]+1, szComp, TRUE)) {
lpstd->behavior = behavior = fScreen;
lpstd->MSflags = fDestroy;
}
if (ppl->ckbMem != -1 && ppl->ckbMem != 1)
lpstd->minmem = lpstd->maxmem = (WORD) ppl->ckbMem;
if (AddGroupData(ppl, szW386HDRSIG30, NULL, sizeof(W386PIF30))) {
if (NULL != (lp386 = GetGroupData(ppl, szW386HDRSIG30, NULL, NULL))) {
lp386->PfW386minmem = lpstd->minmem;
lp386->PfW386maxmem = lpstd->maxmem;
lp386->PfFPriority = TSKFGND_OLD_DEFAULT;
lp386->PfBPriority = TSKBGND_OLD_DEFAULT;
lp386->PfMinEMMK = memDefault.wMinEMS;
lp386->PfMaxEMMK = memDefault.wMaxEMS;
lp386->PfMinXmsK = memDefault.wMinXMS;
lp386->PfMaxXmsK = memDefault.wMaxXMS;
lp386->PfW386Flags = fBackground + fPollingDetect + fINT16Paste;
if (behavior & fScreen)
lp386->PfW386Flags |= fFullScreen;
lp386->PfW386Flags2 = fVidTxtEmulate + fVidNoTrpTxt + fVidNoTrpLRGrfx + fVidNoTrpHRGrfx + fVidTextMd;
}
}
VERIFYTRUE(AddEnhancedData(ppl, lp386));
if (AddGroupData(ppl, szWNTHDRSIG31, NULL, sizeof(WNTPIF31))) {
LPWNTPIF31 lpnt31;
if (NULL != (lpnt31 = GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL))) {
lstrcpyA( lpnt31->nt31Prop.achConfigFile, NT_CONFIG_FILE );
lstrcpyA( lpnt31->nt31Prop.achAutoexecFile, NT_AUTOEXEC_FILE );
}
}
VERIFYTRUE(AddGroupData(ppl, szWNTHDRSIG40, NULL, sizeof(WNTPIF40)));
// Can't be dirty anymore, 'cause we just set everything to defaults
ppl->flProp &= ~PROP_DIRTY;
if (!fLocked)
ppl->cLocks--;
}
else
ASSERTFAIL();
}
/** OpenPIFFile - Wrapper around CreateFile for opening PIF files
*
* The wrapper handles the following things:
*
* Passing the proper access and sharing flags to CreateFile.
* Setting pof->nErrCode = 0 on success.
* Converting ERROR_PATH_NOT_FOUND to ERROR_FILE_NOT_FOUND.
*
* INPUT
*
* pszFile -> name of file to attempt to open
* pof -> PIFOFSTRUCT to fill in
*
* OUTPUT
*
* Same return code as CreateFile.
*
*/
HANDLE OpenPIFFile(LPCTSTR pszFile, LPPIFOFSTRUCT pof)
{
HANDLE hf;
TCHAR pszFullFile[ MAX_PATH ];
LPTSTR pszTheFile;
DWORD dwRet;
//
// CreateFile does not search the path, so do that first, then
// give CreateFile a fully qualified file name to open...
//
dwRet = SearchPath( NULL,
pszFile,
NULL,
ARRAYSIZE(pszFullFile),
pszFullFile,
&pszTheFile
);
if ((dwRet==0) || (dwRet > ARRAYSIZE(pszFullFile)))
{
pszTheFile = (LPTSTR)pszFile;
}
else
{
pszTheFile = pszFullFile;
}
hf = CreateFile( pszTheFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
if (hf == INVALID_HANDLE_VALUE)
{
pof->nErrCode = GetLastError();
if (pof->nErrCode == ERROR_PATH_NOT_FOUND)
pof->nErrCode = ERROR_FILE_NOT_FOUND;
}
else
{
LPTSTR lpDummy;
//
// NOTE: Special hack for creating shortcuts. If the PIF file
// that we find is 0 bytes long, pretend we did not find one at all.
// This is because appwiz renames a 0 length file from "New shortcut.lnk"
// to "appname.pif" and we end up finding it. We'll ignore this file.
//
if (SetFilePointer( hf, 0, NULL, FILE_END) == 0)
{
CloseHandle( hf );
hf = INVALID_HANDLE_VALUE;
pof->nErrCode = ERROR_FILE_NOT_FOUND;
}
else
{
LPCTSTR pszNewFile;
TCHAR szTemp[ ARRAYSIZE(pof->szPathName) ];
SetFilePointer( hf, 0, NULL, FILE_BEGIN );
pof->nErrCode = ERROR_SUCCESS;
// In some cases, people pass in two pointers to the same
// buffer. This will hose GetFullPathName, so if they
// are the same, then make a copy before calling GetFullPathName.
if (pszTheFile==pof->szPathName) {
FillMemory( szTemp, sizeof(szTemp), 0 );
lstrcpy( szTemp, pszTheFile );
pszNewFile = szTemp;
}
else
{
pszNewFile = pszTheFile;
}
GetFullPathName( pszNewFile, ARRAYSIZE(pof->szPathName),
pof->szPathName, &lpDummy );
}
}
return hf;
}
/** PifMgr_OpenProperties - return handle to property info for application
*
* INPUT
* lpszApp -> name of application
* lpszPIF -> name of PIF file to use/create
* hInf = Inf handle, 0 if none, -1 to inhibit Inf processing
* flOpt = OPENPROPS_RAWIO to allow raw file updates; otherwise, 0
*
* OUTPUT
* handle to properties, FALSE if could not be opened, or out of memory
*
* REMARKS
* This should not be thought of as a function that opens a file somewhere
* on the disk (although that's usually the effect), but rather as an
* property structure allocator that is optionally initialized by disk data
* (currently, the file does not even remain open after this call). So the
* main reason for failure in this function will be either a low memory
* condition *or* inability to open a specific PIF file.
*
* The rules for PIF file searching are as follows:
*
* If not a .PIF file:
* Search in current directory.
* Endif.
*
* If path components were specified:
* Search in specified directory.
* Endif.
*
* Search in PIF directory.
* Search the path.
*
* Note that this differs from the Windows 3.1 PIF search algorithm, which
* was...
*
* Search current directory.
* Search the path.
* Search in application directory.
*
* This was a really bogus search order. Fortunately, it seems that
* very few people relied on it.
*
* Things to watch out for when dorking the PIF file search order:
*
* Make sure editing PIF properties from the shell works. (I.e.,
* if a full path to a PIF is given, then use it; don't search.)
*
* Extra special thing to watch out for when dorking the PIF file
* search order:
*
* MS Delta execs its child process as follows:
*
* CreatePif("C:\DELTA\DELTABAT.PIF");
* SetCurrentDirectory("C:\RANDOM\PLACE");
* WinExec("C:\TMP\DELTABAT.BAT", SW_HIDE);
*
* It expects the PIF search to pick up C:\DELTA\DELTABAT.PIF
* from the path, even though the WinExec supplied a full path.
*
*/
HANDLE WINAPI PifMgr_OpenProperties(LPCTSTR lpszApp, LPCTSTR lpszPIF, UINT hInf, UINT flOpt)
{
PPROPLINK ppl;
LPTSTR pszExt;
BOOL fError = FALSE;
BOOL fFixedDisk = FALSE;
BOOL fSearchInf = FALSE;
BOOL fExplicitPIF = FALSE;
PROPPRG prg;
PROPNT40 nt40;
LPTSTR pszName, pszFullName;
#ifdef DBCS
PROPENV env;
#endif
FunctionName(PifMgr_OpenProperties);
// Allocate new prop
if (!(ppl = (PPROPLINK)LocalAlloc(LPTR, sizeof(PROPLINK))))
return 0;
if (!(pszFullName = (LPTSTR)LocalAlloc(LPTR, MAXPATHNAME*sizeof(TCHAR)))) {
EVAL(LocalFree(ppl) == NULL);
return 0;
}
if ((HANDLE)ppl > g_offHighestPropLink) {
g_offHighestPropLink = (HANDLE)ppl;
}
// Initialize the new prop
ppl->ppl = ppl;
ppl->ckbMem = -1;
ppl->iSig = PROP_SIG;
ppl->hPIF = INVALID_HANDLE_VALUE;
if (flOpt & OPENPROPS_RAWIO)
ppl->flProp |= PROP_RAWIO;
#if (PRGINIT_INHIBITPIF != PROP_INHIBITPIF)
#error PRGINIT_INIHIBITPIF and PROP_INHIBITPIF out of sync!
#endif
ppl->flProp |= (flOpt & PROP_INHIBITPIF);
// Link into the global list
if (NULL != (ppl->pplNext = g_pplHead))
g_pplHead->pplPrev = ppl;
g_pplHead = ppl;
// Copy app name to both temp and perm buffers, and record location
// of base filename, and extension if any, within the buffer
lstrcpyn(pszFullName, lpszApp, MAXPATHNAME-4);
lstrcpyn(ppl->szPathName, pszFullName, ARRAYSIZE(ppl->szPathName));
if (NULL != (pszName = StrRChr(pszFullName, NULL, TEXT('\\'))) ||
NULL != (pszName = StrRChr(pszFullName, NULL, TEXT(':'))))
pszName++;
else
pszName = pszFullName;
if (!(pszExt = StrRChr(pszName, NULL, TEXT('.'))))
pszExt = pszFullName + lstrlen(pszFullName);
ppl->iFileName = (UINT) (pszName - pszFullName);
ppl->iFileExt = (UINT) (pszExt - pszFullName);
// Check the application's file extension
if (!*pszExt) {
lstrcat(pszFullName, apszAppType[APPTYPE_PIF]);
}
else if (!lstrcmpi(pszExt, apszAppType[APPTYPE_EXE]) ||
!lstrcmpi(pszExt, apszAppType[APPTYPE_COM]) ||
!lstrcmpi(pszExt, apszAppType[APPTYPE_BAT])) {
// !lstrcmpi(pszExt, apszAppType[APPTYPE_CMD])) {
lstrcpy(pszExt, apszAppType[APPTYPE_PIF]);
}
else if (!lstrcmpi(pszExt, apszAppType[APPTYPE_PIF]))
fExplicitPIF = TRUE;
else {
// Let's disallow random file extensions, since WinOldAp never
// allowed them either
goto Error;
}
// INFONLY means the caller just wants to search the INF, so ignore
// any WIN.INI garbage and any PIFs laying around. We still look for
// _DEFAULT.PIF, since that code takes care of other important
// initialization that needs to happen when no PIF was found at all.
if (flOpt & OPENPROPS_INFONLY)
goto FindDefault;
// Backward compatibility requires that if the app is not a PIF,
// then we must check the PIF section of WIN.INI for an entry matching
// the base name of the app. If the entry exists, then we have to skip
// the PIF search, and pass the value of the entry to InitProperties,
// which it uses to establish default memory requirements
//
// Also note that if IGNOREPIF is set, then ofPIF.szPathName is nothing
// more than the name of the app that was given to PifMgr_OpenProperties; this
// may give us the opportunity to do something more intelligent later...
if (!fExplicitPIF) {
ppl->ckbMem = GetProfileInt(apszAppType[APPTYPE_PIF]+1, ppl->szPathName+ppl->iFileName, -1);
if (ppl->ckbMem != -1) {
ppl->flProp |= PROP_IGNOREPIF | PROP_SKIPPIF;
lstrcpyn(ppl->ofPIF.szPathName, lpszApp, ARRAYSIZE(ppl->ofPIF.szPathName));
goto IgnorePIF; // entry exists, skip PIF file search
}
}
//
// Initialize default error return code. Once we get a successful
// open, it will be set to zero.
//
ppl->flProp |= PROP_NOCREATEPIF;
ppl->ofPIF.nErrCode = ERROR_FILE_NOT_FOUND;
//
// We must search in the current directory if not given a path to a PIF.
// We need to prefix `.\' to the filename so that OpenFile will not do
// a path search.
//
if (!fExplicitPIF || pszName == pszFullName) {
//
// This relies on a feature of OpenFile, that it copies the input
// buffer to a private buffer before stomping the output buffer,
// thus permitting precisely the stunt we are pulling here, namely,
// passing an input buffer equal to the output buffer.
//
*(LPDWORD)(ppl->ofPIF.szPathName) = 0x005C002E; /*dot backslash prefix */
lstrcpyn( &ppl->ofPIF.szPathName[2],
pszName,
ARRAYSIZE(ppl->ofPIF.szPathName) - 2);
ppl->hPIF = OpenPIFFile(ppl->ofPIF.szPathName, &ppl->ofPIF);
}
//
// If we were given a path component, then look in that directory.
// (The fact that we have a backslash or drive letter will suppress
// the path search.)
//
if (pszName != pszFullName && ppl->ofPIF.nErrCode == ERROR_FILE_NOT_FOUND) {
ppl->hPIF = OpenPIFFile(pszFullName, &ppl->ofPIF);
// If we didn't find a PIF there, we'd probably still like to create
// one there if the media is a fixed disk. Network shares, CD-ROM
// drives, and floppies are not good targets for PIF files in general.
//
// So, if the media is a fixed disk, set the fFixedDisk flag so that
// we'll leave pszFullName alone.
if (ppl->hPIF == INVALID_HANDLE_VALUE && pszFullName[1] == TEXT(':')) {
TCHAR szTemp[4];
lstrcpyn( szTemp, pszFullName, 4 );
szTemp[3] = (TCHAR)0;
if (GetDriveType(szTemp) == DRIVE_FIXED)
fFixedDisk++;
}
}
// PERF: replace this PIF dir search with a registry search -JTP
//
// Failing that, let's look in the PIF directory. Again, since we're
// supplying a full pathname, OpenFile won't try to search the PATH again.
if (ppl->ofPIF.nErrCode == ERROR_FILE_NOT_FOUND) {
GetPIFDir(pszName);
ppl->hPIF = OpenPIFFile(g_szPIFDir, &ppl->ofPIF);
if (ppl->hPIF != INVALID_HANDLE_VALUE)
ppl->flProp |= PROP_PIFDIR;
}
// If we're still in trouble, our last chance is to do a path
// search. This is an unconditional search, thanks to the
// wonders of MS-Delta.
if (ppl->ofPIF.nErrCode == ERROR_FILE_NOT_FOUND) {
ppl->hPIF = OpenPIFFile(pszName, &ppl->ofPIF);
}
if (ppl->hPIF == INVALID_HANDLE_VALUE) {
if (ppl->ofPIF.nErrCode != ERROR_FILE_NOT_FOUND || fExplicitPIF) {
// Hmmm, file *may* exist, but it cannot be opened; if it's a
// strange error, or we were specifically told to open that file,
// then return error
goto Error;
}
FindDefault:
fSearchInf = TRUE;
ppl->flProp &= ~PROP_NOCREATEPIF;
// Any files we find now are NOT really what we wanted, so save
// the name we'd like to use in the future, in case we need to save
// updated properties later.
//
// We must save the name now because we might stomp g_szPIFDir while
// searching for the _default.pif. Furthermore, we must save it in
// the buffer we HeapAlloc'ed (pszFullName) temporarily, because
// the following calls to OpenPIFFile can still stomp on szPathName
// in our OpenFile structure (ofPIF.szPathName).
GetPIFDir(pszName);
if (!fFixedDisk) // save desired name in
lstrcpy(pszFullName, g_szPIFDir); // temp buffer (pszFullName)
//
// Try to locate the _default.pif.
//
if (fTryDefaultPif()) {
if (!fDefaultPifFound()) { // Must search for it
// First try PIFDir
lstrcpy(g_szPIFDir+iPIFName, g_szDefaultPIF);
ppl->hPIF = OpenPIFFile(g_szPIFDir, &ppl->ofPIF);
if (ppl->ofPIF.nErrCode == ERROR_FILE_NOT_FOUND) { // try PATH
ppl->hPIF = OpenPIFFile(g_szDefaultPIF, &ppl->ofPIF);
}
} else { // Look in cached path
// We've already found it once, so just open it
ppl->hPIF = OpenPIFFile(g_szDefaultPIF, &ppl->ofPIF);
}
}
if (ppl->hPIF != INVALID_HANDLE_VALUE) {
ppl->flProp |= PROP_DEFAULTPIF;
// Save the fully-qualified pathname of the default PIF file,
// so that subsequent OpenFile() calls will be faster (note that
// we don't specify OF_SEARCH on that particular call)
lstrcpy(g_szDefaultPIF, ppl->ofPIF.szPathName);
}
else {
// Not only could we not open any sort of PIF, we also need to
// tell GetPIFData to not bother trying to open the file itself
// (since it is unlikely someone created one in this short time)
ppl->flProp |= PROP_NOPIF | PROP_SKIPPIF;
if (ppl->ofPIF.nErrCode == ERROR_FILE_NOT_FOUND)
g_szDefaultPIF[0] = 0; // Invalidate cache.
}
// NOW we can set ppl->ofPIF.szPathName to the filename we REALLY
// wanted, since we're done with all the calls to OpenPIFFile.
lstrcpy(ppl->ofPIF.szPathName, pszFullName);
}
// Initialize the properties by PIF if we have one, by hand if not
IgnorePIF:
// We don't need to check the return code from GetPIFData() here,
// because we validate hPIFData below anyway. Please also note that
// this GetPIFData call uses the handle we supplied (if any), and closes
// it for us when it's done. Furthermore, if we didn't supply a handle,
// then we should have set PROP_SKIPPIF, so that GetPIFData won't try to
// open anything (since we just tried!)
GetPIFData(ppl, FALSE);
// Now that the original file from which we obtained settings (if any) is
// closed, we need to see if the caller wants us to create a new PIF file
// using a specific name. If so, force it to be created now.
if (lpszPIF) {
lstrcpy(ppl->ofPIF.szPathName, lpszPIF);
ppl->flProp |= PROP_DIRTY;
ppl->flProp &= ~PROP_NOCREATEPIF;
fError = !FlushPIFData(ppl, FALSE);
}
// Apply INF data to the PIF data we just retrieved, as appropriate,
// as long as it's an app file and not a PIF file (and if, in the case of
// creating a specific PIF, we were actually able to create one).
if (!fError && !fExplicitPIF && (hInf != -1)) {
if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_PRG),
&prg, sizeof(prg), GETPROPS_NONE)) {
// In the PRGINIT_AMBIGUOUSPIF case, GetAppsInfData must
// again look for a matching entry; however, if the entry it
// finds is the same as what we've already got (based on Other
// File), then it will leave the PIF data alone (ie, it doesn't
// reinitialize it, it doesn't call AppWiz to silently
// reconfigure it, etc).
if (fSearchInf || (prg.flPrgInit & PRGINIT_AMBIGUOUSPIF)) {
if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_NT40),
&nt40, sizeof(nt40), GETPROPS_NONE)) {
if (!GetAppsInfData(ppl, &prg, &nt40, (HINF)IntToPtr( hInf ), lpszApp, fFixedDisk, flOpt)) {
// When GetAppsInfData fails and the PIF is ambiguous, then
// we need to restart the PIF search process at the point where
// it searches for _DEFAULT.PIF, so that the ambiguous PIF is
// effectively ignored now.
// Also, we avoid the ugly possibility of getting to this
// point again and infinitely jumping back FindDefault, by
// only jumping if fSearchInf was FALSE. FindDefault sets
// it to TRUE.
if (!fSearchInf && (prg.flPrgInit & PRGINIT_AMBIGUOUSPIF)) {
goto FindDefault;
}
#ifdef DBCS
if (GetSystemDefaultLangID() == 0x0411) {
ZeroMemory(&env, sizeof(env));
lstrcpyA(env.achBatchFile, ImeBatchFile);
PifMgr_SetProperties(ppl, MAKELP(0,GROUP_ENV),
&env, sizeof(env), SETPROPS_NONE);
}
#endif
}
}
}
}
}
Error:
LocalFree(pszFullName);
if (fError || !ppl->lpPIFData) {
PifMgr_CloseProperties(ppl, 0);
return 0;
}
// We should never leave PIFMGR with outstanding locks
ASSERTTRUE(!ppl->cLocks);
return ppl;
}
/** PifMgr_GetProperties - get property info by name
*
* INPUT
* hProps = handle to properties
* lpszGroup -> property group; may be one of the following:
* "WINDOWS 286 3.0"
* "WINDOWS 386 3.0"
* "WINDOWS VMM 4.0"
* "WINDOWS NT 3.1"
* "WINDOWS NT 4.0"
* or any other group name that is the name of a valid PIF extension;
* if NULL, then cbProps is a 0-based index of a named group, and lpProps
* must point to a 16-byte buffer to receive the name of the group (this
* enables the caller to enumerate the names of all the named groups)
* lpProps -> property group record to receive the data
* cbProps = size of property group record to get; if cbProps is zero
* and a named group is requested, lpProps is ignored, no data is copied,
* and the size of the group record is returned (this enables the caller
* to determine the size of a named group)
* flOpt = GETPROPS_RAWIO to perform raw file read (lpszGroup ignored)
*
* Alternatively, if the high word (selector) of lpszGroup is 0, the low
* word must be a group ordinal (eg, GROUP_PRG, GROUP_TSK, etc)
*
* OUTPUT
* If the group is not found, or an error occurs, 0 is returned.
* Otherwise, the size of the group info transferred in bytes is returned.
*/
int WINAPI PifMgr_GetProperties(HANDLE hProps, LPCSTR lpszGroup, void *lpProps, int cbProps, UINT flOpt)
{
int cb, i;
void *lp;
LPW386PIF30 lp386;
LPWENHPIF40 lpenh;
LPWNTPIF40 lpnt40;
LPWNTPIF31 lpnt31;
PPROPLINK ppl;
FunctionName(PifMgr_GetProperties);
cb = 0;
if (!(ppl = ValidPropHandle(hProps)))
return cb;
// We should never enter PIFMGR with outstanding locks (we also call
// here from *inside* PIFMGR, but none of those cases should require a
// lock either)
ASSERTTRUE(!ppl->cLocks);
ppl->cLocks++;
if (flOpt & GETPROPS_RAWIO) {
if (ppl->flProp & PROP_RAWIO) {
cb = min(ppl->cbPIFData, cbProps);
hmemcpy(lpProps, ppl->lpPIFData, cb);
}
ppl->cLocks--;
return cb;
}
if (!lpszGroup) {
if (lpProps) {
lp = GetGroupData(ppl, NULL, &cbProps, NULL);
if (lp) {
cb = cbProps;
hmemcpy(lpProps, lp, PIFEXTSIGSIZE);
}
}
}
else if (IS_INTRESOURCE(lpszGroup) && lpProps) {
// Special case: if GROUP_ICON, then do a nested call to
// PifMgr_GetProperties to get GROUP_PRG data, then feed it to load
// LoadPIFIcon, and finally return the hIcon, if any, to the user.
if (LOWORD((DWORD_PTR) lpszGroup) == GROUP_ICON) {
PPROPPRG pprg;
PPROPNT40 pnt40 = (void *)LocalAlloc(LPTR, sizeof(PROPNT40));
if ( pnt40 ) {
pprg = (void *)LocalAlloc(LPTR, sizeof(PROPPRG));
if (pprg) {
if ( PifMgr_GetProperties(ppl, MAKELP(0,GROUP_PRG), pprg, sizeof(PROPPRG), GETPROPS_NONE)
&& PifMgr_GetProperties(ppl, MAKELP(0,GROUP_NT40), pnt40, sizeof(PROPNT40), GETPROPS_NONE) ) {
*(HICON *)lpProps = LoadPIFIcon(pprg, pnt40);
cb = 2;
}
EVAL(LocalFree(pprg) == NULL);
}
EVAL(LocalFree(pnt40) == NULL);
}
}
else {
lp386 = GetGroupData(ppl, szW386HDRSIG30, NULL, NULL);
lpenh = GetGroupData(ppl, szWENHHDRSIG40, NULL, NULL);
lpnt40 = GetGroupData(ppl, szWNTHDRSIG40, NULL, NULL);
lpnt31 = GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL);
//
// Fix anything from down-level PIF files. Since this
// is the first revision of the WENHPIF40 format, we
// don't have anything to worry about (yet).
//
// Don't muck with PIF files from the future!
//
if (lpenh && lpenh->wInternalRevision != WENHPIF40_VERSION) {
lpenh->wInternalRevision = WENHPIF40_VERSION;
ppl->flProp |= PROP_DIRTY;
//
// Old (pre-M7) PIFs did not zero-initialize the reserved
// fields of PIF files, so zero them out now.
//
lpenh->tskProp.wReserved1 = 0;
lpenh->tskProp.wReserved2 = 0;
lpenh->tskProp.wReserved3 = 0;
lpenh->tskProp.wReserved4 = 0;
lpenh->vidProp.wReserved1 = 0;
lpenh->vidProp.wReserved2 = 0;
lpenh->vidProp.wReserved3 = 0;
lpenh->envProp.wMaxDPMI = 0;
// Turn off bits that have been deleted during the development
// cycle.
lpenh->envProp.flEnv = 0;
lpenh->envProp.flEnvInit = 0;
if (lp386)
lp386->PfW386Flags &= ~0x00400000;
}
// End of "Remove this after M8"
// Zero the input buffer first, so that the Get* functions
// need not initialize every byte to obtain consistent results
BZero(lpProps, cbProps);
// The GetData functions CANNOT rely on either lp386 or lpenh
i = LOWORD((DWORD_PTR) lpszGroup)-1;
if (i >= 0 && i < ARRAYSIZE(afnGetData) && cbProps >= acbData[i]) {
void *aDataPtrs[NUM_DATA_PTRS];
aDataPtrs[ LP386_INDEX ] = (LPVOID)lp386;
aDataPtrs[ LPENH_INDEX ] = (LPVOID)lpenh;
aDataPtrs[ LPNT40_INDEX ] = (LPVOID)lpnt40;
aDataPtrs[ LPNT31_INDEX ] = (LPVOID)lpnt31;
cb = (afnGetData[i])(ppl, aDataPtrs, lpProps, cbProps, flOpt );
}
}
}
else if (NULL != (lp = GetGroupData(ppl, lpszGroup, &cb, NULL))) {
if (lpProps && cbProps != 0) {
cb = min(cb, cbProps);
hmemcpy(lpProps, lp, cb);
}
}
ppl->cLocks--;
#ifdef EXTENDED_DATA_SUPPORT
// Note that for GETPROPS_EXTENDED, both the normal and extended
// sections are returned, and that the return code reflects the success
// or failure of reading the normal portion only. We return both because
// that's the most convenient thing to do for the caller.
if (flOpt & GETPROPS_EXTENDED) {
if (ppl->hVM) {
WORD wGroup = EXT_GROUP_QUERY;
if (!HIWORD(lpszGroup) && LOWORD(lpszGroup) <= MAX_GROUP)
wGroup |= LOWORD(lpszGroup);
GetSetExtendedData(ppl->hVM, wGroup, lpszGroup, lpProps);
}
}
#endif
// We should never leave PIFMGR with outstanding locks (we also call
// here from *inside* PIFMGR, but none of those cases should require a
// lock either)
ASSERTTRUE(!ppl->cLocks);
return cb;
}
/** PifMgr_SetProperties - set property info by name
*
* INPUT
* hProps = handle to properties
* lpszGroup -> property group; may be one of the following:
* "WINDOWS 286 3.0"
* "WINDOWS 386 3.0"
* "WINDOWS PIF.400"
* or any other group name that is the name of a valid PIF extension
* lpProps -> property group record to copy the data from
* cbProps = size of property group record to set; if cbProps is
* zero and lpszGroup is a group name, the group will be removed
* flOpt = SETPROPS_RAWIO to perform raw file write (lpszGroup ignored)
* SETPROPS_CACHE to cache changes until properties are closed
*
* Alternatively, if the high word (selector) of lpszGroup is 0, the low
* word must be a group ordinal (eg, GROUP_PRG, GROUP_TSK, etc)
*
* OUTPUT
* If the group is not found, or an error occurs, 0 is returned.
* Otherwise, the size of the group info transferred in bytes is returned.
*/
int WINAPI PifMgr_SetProperties(HANDLE hProps, LPCSTR lpszGroup, void *lpProps, int cbProps, UINT flOpt)
{
void *p = NULL;
void *lp = NULL;
LPW386PIF30 lp386;
LPWENHPIF40 lpenh;
LPWNTPIF40 lpnt40;
LPWNTPIF31 lpnt31;
int i, cb = 0;
PPROPLINK ppl;
FunctionName(PifMgr_SetProperties);
// Can't set a NULL name (nor set-by-index)--causes squirlly behavior in RemoveGroupData
if (!lpProps || !lpszGroup)
return 0;
ppl = ValidPropHandle(hProps);
if (!ppl)
return 0;
// We should never enter PIFMGR with outstanding locks (we also call
// here from *inside* PIFMGR, but none of those cases should require a
// lock either)
ASSERTTRUE(!ppl->cLocks);
if (flOpt & SETPROPS_RAWIO) {
if (ppl->flProp & PROP_RAWIO) {
ppl->cLocks++;
cb = min(ppl->cbPIFData, cbProps);
if (IsBufferDifferent(ppl->lpPIFData, lpProps, cb)) {
hmemcpy(ppl->lpPIFData, lpProps, cb);
ppl->flProp |= PROP_DIRTY;
}
if (cb < ppl->cbPIFData)
ppl->flProp |= PROP_DIRTY | PROP_TRUNCATE;
ppl->cbPIFData = cb;
ppl->cLocks--;
}
return cb;
}
#ifdef EXTENDED_DATA_SUPPORT
// Note that, unlike GETPROPS_EXTENDED, SETPROPS_EXTENDED only updates
// the extended section, and that the return code reflects the existence
// of a VM only. This is because there's a performance hit associated
// with setting the normal portion, and because the caller generally only
// wants to set one or the other.
if (flOpt & SETPROPS_EXTENDED) {
if (ppl->hVM) {
WORD wGroup = EXT_GROUP_UPDATE;
cb = cbProps;
if (!HIWORD(lpszGroup) && LOWORD(lpszGroup) <= MAX_GROUP)
wGroup |= LOWORD(lpszGroup);
GetSetExtendedData(ppl->hVM, wGroup, lpszGroup, lpProps);
}
return cb;
}
#endif
// For named groups, if the group does NOT exist, or DOES but is
// a different size, then we have to remove the old data, if any, and
// then add the new.
if (!IS_INTRESOURCE(lpszGroup)) {
cb = PifMgr_GetProperties(hProps, lpszGroup, NULL, 0, GETPROPS_NONE);
if (cb == 0 || cb != cbProps) {
if (cb) {
RemoveGroupData(ppl, lpszGroup);
cb = 0;
}
if (cbProps) {
if (AddGroupData(ppl, lpszGroup, lpProps, cbProps))
cb = cbProps;
}
goto done;
}
}
if (cbProps) {
if (!lpszGroup)
return cb;
p = (void *)LocalAlloc(LPTR, cbProps);
if (!p)
return cb;
}
cb = PifMgr_GetProperties(hProps, lpszGroup, p, cbProps, GETPROPS_NONE);
// If the group to set DOES exist, and if the data given is
// different, copy into the appropriate group(s) in the PIF data
if (cb != 0) {
cbProps = min(cb, cbProps);
if (IsBufferDifferent(p, lpProps, cbProps)) {
cb = 0;
ppl->cLocks++;
i = LOWORD((DWORD_PTR) lpszGroup)-1;
if (!IS_INTRESOURCE(lpszGroup)) {
lp = GetGroupData(ppl, lpszGroup, NULL, NULL);
if (lp) {
cb = cbProps;
hmemcpy(lp, lpProps, cbProps);
ppl->flProp |= PROP_DIRTY;
}
}
else if (i >= 0 && i < ARRAYSIZE(afnSetData) && cbProps >= acbData[i]) {
// Insure that both 386 and enhanced sections of PIF
// file are present. There are some exceptions: all
// groups from GROUP_MSE on up do not use the 386 section,
// and GROUP_MEM does not need the enh section....
lp386 = GetGroupData(ppl, szW386HDRSIG30, NULL, NULL);
if (i < GROUP_MSE-1 && !lp386) {
if (AddGroupData(ppl, szW386HDRSIG30, NULL, sizeof(W386PIF30))) {
lp386 = GetGroupData(ppl, szW386HDRSIG30, NULL, NULL);
if (!lp386) {
ASSERTFAIL();
cbProps = 0; // indicate error
}
}
}
if (cbProps) {
lpenh = GetGroupData(ppl, szWENHHDRSIG40, NULL, NULL);
if (i != GROUP_MEM-1 && !lpenh) {
if (!(lpenh = AddEnhancedData(ppl, lp386))) {
ASSERTFAIL();
cbProps = 0; // indicate error
}
}
lpnt40 = GetGroupData(ppl, szWNTHDRSIG40, NULL, NULL);
if (!lpnt40)
{
if (AddGroupData(ppl, szWNTHDRSIG40, NULL, sizeof(WNTPIF40)))
{
lpnt40 = GetGroupData(ppl, szWNTHDRSIG40, NULL, NULL);
}
}
ASSERT(lpnt40);
lpnt31 = GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL);
if (!lpnt31)
{
if (AddGroupData(ppl, szWNTHDRSIG31, NULL, sizeof(WNTPIF31)))
{
if (NULL != (lpnt31 = GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL))) {
lstrcpyA( lpnt31->nt31Prop.achConfigFile, NT_CONFIG_FILE );
lstrcpyA( lpnt31->nt31Prop.achAutoexecFile, NT_AUTOEXEC_FILE );
}
}
}
ASSERT(lpnt31);
}
if (cbProps)
{
void *aDataPtrs[NUM_DATA_PTRS];
//
// We need to re-establish the pointers because any of
// the AddGroupData's could have moved the block (via
// a HeapReAlloc call), so do that now...
//
lp386 = GetGroupData( ppl, szW386HDRSIG30, NULL, NULL );
lpenh = GetGroupData( ppl, szWENHHDRSIG40, NULL, NULL );
lpnt40 = GetGroupData( ppl, szWNTHDRSIG40, NULL, NULL );
lpnt31 = GetGroupData( ppl, szWNTHDRSIG31, NULL, NULL );
aDataPtrs[ LP386_INDEX ] = (LPVOID)lp386;
aDataPtrs[ LPENH_INDEX ] = (LPVOID)lpenh;
aDataPtrs[ LPNT40_INDEX ] = (LPVOID)lpnt40;
aDataPtrs[ LPNT31_INDEX ] = (LPVOID)lpnt31;
cb = (afnSetData[i])(ppl, aDataPtrs, lpProps, cbProps, flOpt );
}
}
ppl->cLocks--;
}
}
EVAL(LocalFree(p) == NULL);
done:
if (!(flOpt & SETPROPS_CACHE))
if (!FlushPIFData(ppl, FALSE))
cb = 0;
// We should never leave PIFMGR with outstanding locks (we also call
// here from *inside* PIFMGR, but none of those cases should require a
// lock either)
ASSERTTRUE(!ppl->cLocks);
return cb;
}
/** FlushProperties - flush (or discard) any cached property info
*
* INPUT
* hProps = handle to properties
* flOpt = FLUSHPROPS_DISCARD to abandon cached PIF data, otherwise flush it
*
* OUTPUT
* TRUE if successful, FALSE otherwise
*/
int WINAPI FlushProperties(HANDLE hProps, UINT flOpt)
{
PPROPLINK ppl;
FunctionName(FlushProperties);
if (!(ppl = ValidPropHandle(hProps)))
return FALSE;
return FlushPIFData(ppl, (flOpt & FLUSHPROPS_DISCARD));
}
/** EnumProperties - enumerate open properties
*
* INPUT
* hProps = handle to previous properties (NULL to start)
*
* OUTPUT
* next property handle, 0 if none
*/
HANDLE WINAPI EnumProperties(HANDLE hProps)
{
PPROPLINK ppl;
FunctionName(EnumProperties);
if (!hProps)
return g_pplHead;
if (!(ppl = ValidPropHandle(hProps)))
return NULL;
return ppl->pplNext;
}
/** AssociateProperties - associate data with property info
*
* INPUT
* hProps = handle to properties
* iAssociate = association index (eg, HVM_ASSOCIATION)
* lData = new associated data
*
* OUTPUT
* previously associated data for the index, 0 if none (or error)
*
* NOTES
* If iAssociate is a negative association index, then the current
* associated value is returned and not modified (ie, lData is ignored)
*/
LONG_PTR WINAPI AssociateProperties(HANDLE hProps, int iAssociate, LONG_PTR lData)
{
LONG_PTR l;
int iIndex;
PPROPLINK ppl;
FunctionName(AssociateProperties);
if (!(ppl = ValidPropHandle(hProps)))
return FALSE;
iIndex = iAssociate;
if (iIndex < 0)
iIndex *= -1;
switch(iIndex) {
case HVM_ASSOCIATION:
l = ppl->hVM;
break;
case HWND_ASSOCIATION:
l = (LONG_PTR)ppl->hwndTty;
break;
case LPARGS_ASSOCIATION:
l = (LONG_PTR)ppl->lpArgs;
break;
default:
return FALSE;
}
switch(iAssociate) {
case HVM_ASSOCIATION:
ppl->hVM = (DWORD) lData;
break;
case HWND_ASSOCIATION:
ppl->hwndTty = (HWND)lData;
break;
case LPARGS_ASSOCIATION:
ppl->lpArgs = (LPTSTR)lData;
break;
}
return l;
}
void SetBootDrive(LPTSTR pszFile)
{
TCHAR szPath[10];
DWORD cbPath = sizeof(szPath);
szPath[0] = 0;
SHGetValue(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Setup"), TEXT("BootDir"), NULL, szPath, &cbPath);
pszFile[0] = szPath[0] ? szPath[0] : TEXT('C');
}
#define RENAME_DELETENEW 0x0001
#define RENAME_CREATEOLD 0x0002
#define RENAME_DELETEOLD 0x0004
/** RenameStartupFiles - rename startup files (for real-mode only)
*
* INPUT
* pszOld -> old filename (eg, C:CONFIG.SYS)
* pszNew -> new filename (eg, C:CONFIG.WOS)
* flRename == see RENAME_* above
*
* OUTPUT
* None
*/
void RenameStartupFiles(LPTSTR pszOld, LPTSTR pszNew, int flRename)
{
SetBootDrive(pszOld);
SetBootDrive(pszNew);
// For RENAME_DELETENEW: make sure there's no way an existing new filename
// could block the rename process, not even a R/H/S file!
if (flRename & RENAME_DELETENEW) {
SetFileAttributes(pszNew, 0);
DeleteFile(pszNew);
}
// For RENAME_CREATEOLD: if the old filename doesn't exist, then we
// want to create a hidden 0-length copy of the new filename, as a way
// of telling ourselves later that the old file didn't exist. Then,
// when it's later (see RENAME_DELETEOLD), if the file we're to rename
// is a hidden 0-length file, just delete it.
if (flRename & RENAME_CREATEOLD) {
int i;
HANDLE hFile;
i = (int)GetFileAttributes(pszOld);
if (i == -1) {
hFile = CreateFile( pszNew,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_HIDDEN,
NULL
);
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
return;
}
}
// For RENAME_DELETEOLD: if the old file is a hidden 0-length
// dummy file that we presumably created ourselves, then simply delete it.
if (flRename & RENAME_DELETEOLD) {
WIN32_FIND_DATA dFind;
HANDLE hFind = FindFirstFile(pszOld, &dFind);
if (hFind != INVALID_HFINDFILE) {
FindClose(hFind);
if ((dFind.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) && dFind.nFileSizeLow == 0) {
DeleteFile(pszOld);
return;
}
}
}
MoveFile(pszOld, pszNew);
}
/** CheckForceReboot - return TRUE if exit to real-mode has been disabled
*
* This function largely copied from win\core\user\inexit.c -JTP
*
* The key being examined is:
*
* HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Shutdown
*
* The value-name is:
*
* ForceReboot
*
* The value to force a reboot is:
*
* "1"
*
* INPUT
* None
*
* OUTPUT
* TRUE if reboot must be forced, FALSE if not
*/
BOOL CheckForceReboot()
{
// Check to see if we have to force a reboot of the system. One reason is
// so that the double space utilities can tell us the system must be reboot
// since we can't exit to real mode double space...
HKEY hkey;
static TCHAR szShutdown[] = REGSTR_PATH_SHUTDOWN;
BOOL fForce=FALSE;
TCHAR sz[12];
DWORD dwType;
if (!RegOpenKey(HKEY_LOCAL_MACHINE, szShutdown, &hkey))
{
LONG cb = sizeof(sz);
static TCHAR szForceReboot[] = REGSTR_VAL_FORCEREBOOT;
if (!SHQueryValueEx(hkey, szForceReboot, NULL, &dwType, (LPBYTE)sz, &cb))
{
if (*sz==TEXT('1'))
fForce = TRUE;
}
RegCloseKey(hkey);
}
return(fForce);
}
/** CreateStartupProperties - create startup files (for real-mode only)
*
* INPUT
* hProps = handle to properties
* flOpt = CREATEPROPS_NONE (all bits reserved)
*
* OUTPUT
* TRUE (1) if any files were created, FALSE (0) if there was an error
* creating 1 or more of the necessary files, and -1 there was no error and
* no files needed to be created.
*/
int WINAPI CreateStartupProperties(HANDLE hProps, UINT flOpt)
{
BOOL fForceReboot;
int fSuccess = FALSE;
PPROPLINK ppl;
FunctionName(CreateStartupProperties);
if (NULL != (ppl = ValidPropHandle(hProps))) {
InitRealModeFlag(ppl);
if (ppl->flProp & PROP_REALMODE) {
// WriteAdvPrgData only returns the exact value TRUE (1) if it
// actually created a file. If there was no need to create
// a particular file, and therefore no error, it returns -1.
fForceReboot = CheckForceReboot();
fSuccess = WriteAdvPrgData(ppl, MAX_CONFIG_SIZE, szCONFIGHDRSIG40, g_szMConfigFile, g_szConfigFile, fForceReboot, fForceReboot);
fSuccess &= WriteAdvPrgData(ppl, MAX_AUTOEXEC_SIZE, szAUTOEXECHDRSIG40, g_szMAutoexecFile, g_szAutoexecFile, fSuccess, fForceReboot);
}
}
return fSuccess;
}
/** DoLargeEnvironmentSubstA - do large environment substitution
*
* NOTE: the below comment is no longer true. DoEnvironmentSubst
* calls ExpandEnvironmentStrings which does not have this restriction!
*
* This is a wrapper around shell's DoEnvironmentSubst that can handle
* larger buffers. Although not well-documented, DoEnvironmentSubst will
* fail if the input buffer simply contains more than 256 chars, hence
* it is not entirely suitable for our purposes.
*
* The basic idea is: find CR/LF-terminated lines, copy them to szTmp
* with a null terminator instead of the CR/LF, do environment substitution
* on szTmp, move the data in psz up by the number of bytes szTmp grew (if
* any), and then copy the expanded string back into psz. Repeat until no
* more lines.
*/
int DoLargeEnvironmentSubstA(LPSTR psz, int cchsz, BOOL fStripWIN)
{
int cch, cchNew, cchDiff;
DWORD dwResult;
CHAR szTmp[256];
CHAR *pszCRLF, *pszCRLFNext;
pszCRLF = psz;
while (NULL != (pszCRLFNext = (PBYTE)(UINT_PTR)(ULONG_PTR)_fstrstr(pszCRLF, szCRLF))) {
cch = (int)(pszCRLFNext - pszCRLF);
pszCRLFNext += ARRAYSIZE(szCRLF)-1;
if (cch >= ARRAYSIZE(szTmp))
goto Next;
hmemcpy(szTmp, pszCRLF, cch);
szTmp[cch] = '\0';
// fStripWIN means: strip WIN wherever you find it and do NOTHING else
if (fStripWIN) {
if (lstrcmpiA(szTmp, szWin) == 0) {
cchNew = 0;
goto Strip;
}
goto Next;
}
cchNew = cch;
dwResult = DoEnvironmentSubstA(szTmp, ARRAYSIZE(szTmp));
if (HIWORD(dwResult))
cchNew = LOWORD(dwResult);
Strip:
cchDiff = cchNew - cch; // cchDiff == # chars needed
if (cchDiff) {
if (cchDiff > cchsz - (lstrlenA(psz)+1))
goto Next; // not enough room left
cch = lstrlenA(pszCRLFNext)+1;// cch == # chars required to copy
hmemcpy(pszCRLFNext+(cchDiff*sizeof(CHAR)), pszCRLFNext, cch*sizeof(CHAR));
pszCRLFNext += cchDiff;
}
hmemcpy(pszCRLF, szTmp, cchNew*sizeof(CHAR));
hmemcpy(pszCRLF+cchNew, szCRLF, (ARRAYSIZE(szCRLF)-1)*sizeof(CHAR));
Next:
pszCRLF = pszCRLFNext;
}
return lstrlenA(psz);
}
void ReadAdvPrgData(PPROPLINK ppl, int cbMax, LPCSTR lpszName, LPTSTR pszFile, UINT flOpt)
{
HANDLE hFile;
int i;
DWORD cbData = 0, cb;
CHAR szTmp[256];
PBYTE pb, pbLast;
PBYTE pbData = NULL, pbDataTmp, pbDataOrig = NULL;
SetBootDrive(pszFile);
if (flOpt & DELETEPROPS_DISCARD) {
DeleteFile(pszFile);
return;
}
hFile = CreateFile( pszFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
if (hFile != INVALID_HANDLE_VALUE) {
pbData = (PBYTE)LocalAlloc(LPTR, cbMax);
if (pbData) {
pbDataOrig = pbData;
if (ReadFile( hFile, (PVOID)pbData, (DWORD)cbMax-1, &cbData, NULL))
{
// Guess what, this routine isn't so general purpose after all:
// in the autoexec case, we must find the signature that precedes
// the command-line that we added to the file. For expediency,
// we simply delete it and everything after it.
if (pszFile == g_szMConfigFile) {
// If "DOS=SINGLE" is present, skip over it
if (pbData == (PBYTE)(UINT_PTR)(ULONG_PTR)_fstrstr(pbData, szSingle)) {
cb = lstrlenA(szSingle);
pbData += cb;
cbData -= cb;
}
}
if (pszFile == g_szMAutoexecFile) {
// If "@echo off" is present, skip over it
if (LoadStringA(g_hinst, IDS_AUTOEXECTOP, szTmp, ARRAYSIZE(szTmp))) {
if (pbData == (PBYTE)(UINT_PTR)(ULONG_PTR)_fstrstr(pbData, szTmp)) {
cb = lstrlenA(szTmp);
pbData += cb;
cbData -= cb;
}
}
// Try to find our signature at the end of the file now
if (LoadStringA(g_hinst, IDS_AUTOEXECBOTTOM, szTmp, ARRAYSIZE(szTmp))) {
pb = pbData;
pbLast = NULL;
while (NULL != (pb = (PBYTE)(UINT_PTR)(ULONG_PTR)_fstrstr(pb, szTmp))) {
pbLast = pb++;
}
// If there was a (last) occurrence of the signature
// in the file, then it's starting point is where we cut
// off the data we're about to rewrite.
if (pbLast)
cbData = (DWORD) (pbLast - pbData);
}
}
}
}
CloseHandle(hFile);
DeleteFile(pszFile);
}
// Before we simply blast the data back out to the PIF, we check to
// see if the data we're about to write is the same as what's already
// there after environment string substitution. If so, we leave the
// data alone, so that environment strings are left in their pre-expanded
// form whenever possible (and with a minimum of work on our part).
i = -1;
if (NULL != (pbDataTmp = (PBYTE)LocalAlloc(LPTR, cbMax))) {
if (PifMgr_GetProperties(ppl, lpszName, pbDataTmp, cbMax-1, GETPROPS_NONE)) {
DoLargeEnvironmentSubstA(pbDataTmp, cbMax, FALSE);
i = lstrcmpA(pbDataTmp, pbData);
}
EVAL(LocalFree(pbDataTmp) == NULL);
}
// Note that if the file no longer exists, or does but is zero bytes
// long, this call effectively removes the data from the PIF. Otherwise,
// the PIF gets refreshed with the contents of the startup file, which
// we deleted immediately after pulling its contents out.
if (i != 0)
PifMgr_SetProperties(ppl, lpszName, pbData, cbData, SETPROPS_NONE);
if (pbDataOrig)
EVAL(LocalFree(pbDataOrig) == NULL);
}
BOOL WriteAdvPrgData(PPROPLINK ppl, int cbMax, LPCSTR lpszName, LPTSTR pszFile, LPTSTR pszOrigFile, BOOL fCreateAnyway, BOOL fForceReboot)
{
HANDLE hFile;
int cbData, cb, i, j;
PBYTE pbData;
PROPPRG prg;
PROPENV env;
DWORD dwBytes;
BOOL fPause = FALSE;
BOOL fSuccess = FALSE;
CHAR szTmp[MAXPATHNAME];
cbData = PifMgr_GetProperties(ppl, lpszName, NULL, 0, GETPROPS_NONE);
if (!cbData) { // if there's no autoexec data
if (fCreateAnyway != 1) // and no previous file was created
return -1; // then there's no need to create this file
}
// If fCreateAnyway is -1, then we know are being called for AUTOEXEC
// *and* that no file was created for CONFIG. Since we are committed to
// creating an AUTOEXEC now, we therefore *force* the CONFIG file to
// be created as well. That way, the user won't end up with the default
// CONFIG (he may have just not have needed/cared about device drivers, but
// still wanted to run in real-mode).
if (fCreateAnyway == -1) {
if (!WriteAdvPrgData(ppl, MAX_CONFIG_SIZE, szCONFIGHDRSIG40, g_szMConfigFile, g_szConfigFile, TRUE, fForceReboot))
return FALSE;
}
pbData = (PBYTE)LocalAlloc(LPTR, cbMax);
if (pbData) {
if (cbData) {
if (cbData >= cbMax)
cbData = cbMax-1;
PifMgr_GetProperties(ppl, lpszName, pbData, cbData, GETPROPS_NONE);
} else if (fForceReboot) {
SetBootDrive(pszOrigFile);
hFile = CreateFile( pszOrigFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile != INVALID_HANDLE_VALUE) {
cbData = (int)SetFilePointer( hFile, 0, NULL, FILE_END );
if (cbData) {
if (cbData >= cbMax)
cbData = cbMax-1;
SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
if (ReadFile( hFile, pbData, cbData, &dwBytes, NULL)) {
if (dwBytes != (UINT)cbData) {
cbData = 0;
} else {
cbData = (int)dwBytes;
}
}
}
CloseHandle(hFile);
}
}
}
else
cbData = 0;
SetBootDrive( pszFile );
hFile = CreateFile( pszFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL );
if (hFile!=INVALID_HANDLE_VALUE) {
// Do environment string substitution on the buffer before writing
// it out. Treat it like the huge null-terminated string that it is.
if (pbData)
cbData = DoLargeEnvironmentSubstA(pbData, cbMax, fForceReboot);
// Do the simple thing: ALWAYS write out the "@echo off" line;
// if someone really wants to see the batch file execute, let them
// put an explicit "echo on" in their autoexec edit control; since it
// comes after ours, it will override as appropriate.
//
// This rule also simplifies conversion on the way back: if the
// first line is "@echo off", we delete it.
if (pszFile == g_szMConfigFile) {
WriteFile( hFile, szSingle, lstrlenA(szSingle), &dwBytes, NULL );
}
if (pszFile == g_szMAutoexecFile) {
szTmp[0] = '\0';
LoadStringA(g_hinst, IDS_AUTOEXECTOP, szTmp, ARRAYSIZE(szTmp));
WriteFile( hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL );
}
if (WriteFile(hFile, pbData, cbData, &dwBytes, NULL) && (dwBytes==(DWORD)cbData))
fSuccess++; // return TRUE to indicate file created
// Make sure the user-defined gob-o-goo is CR/LF-terminated;
// if not, spit one out.
if (cbData != 0)
if (cbData < 2 || lstrcmpA(pbData+cbData-(ARRAYSIZE(szCRLF)-1), szCRLF) != 0)
WriteFile( hFile, szCRLF, sizeof(szCRLF)-1, &dwBytes, NULL);
// Guess what, this routine isn't so general purpose after all:
// in the autoexec case, we must append the command-line to
// the file, followed by C:\WINDOWS\WIN.COM /W to restore everything
if (pszFile == g_szMAutoexecFile) {
if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_PRG),
&prg, sizeof(prg), GETPROPS_NONE)) {
szTmp[0] = '\0';
LoadStringA(g_hinst, IDS_AUTOEXECBOTTOM, szTmp, ARRAYSIZE(szTmp));
WriteFile(hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL);
// If the program is on drive A, then it is time emit:
//
// ECHO Please insert the diskette for Mickey's ABCs in drive A now
// PAUSE
//
// since WinOldAp will have asked the user to remove it.
if ((ppl->szPathName[0] == TEXT('a') ||
ppl->szPathName[0] == TEXT('A')) && ppl->szPathName[1] == TEXT(':')) {
CHAR szTmpFmt[128];
fPause++;
WriteFile(hFile, szEcho, sizeof(szEcho)-1, &dwBytes, NULL);
szTmpFmt[0] = '\0';
LoadStringA(g_hinst, IDS_DISKINSERT, szTmpFmt, ARRAYSIZE(szTmpFmt));
// The DISKINSERT string should have one %s for the title...
wsprintfA(szTmp, szTmpFmt, prg.achTitle);
WriteFile(hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL);
WriteFile(hFile, szPause, sizeof(szPause)-1, &dwBytes, NULL);
}
if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_ENV),
&env, sizeof(env), GETPROPS_NONE)) {
if (env.achBatchFile[0]) {
WriteFile(hFile, szCall, sizeof(szCall)-1, &dwBytes, NULL);
// env.achBatchFile could be a long filename and/or
// quoted (since it could be followed by args). Take
// care of it now.
i = lstrunquotefnameA(szTmp, env.achBatchFile, ARRAYSIZE(szTmp), TRUE);
j = lstrskipfnameA(env.achBatchFile);
if (env.achBatchFile[j])
lstrcpynA(szTmp+i, env.achBatchFile+j, ARRAYSIZE(szTmp)-i);
WriteFile(hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL);
WriteFile(hFile, szCRLF, sizeof(szCRLF)-1, &dwBytes, NULL);
}
}
#ifdef DBCS
// else if (!GetProperties(ppl, lpszName, NULL, 0, GETPROPS_NONE))
// _lwrite(hFile, szDOSIME, lstrlen(szDOSIME));
#endif
if (!prg.achWorkDir[0]) {
// If there's no hard-coded working directory,
// create one. It's ok to party on prg.achWorkDir because
// we're not going to call PifMgr_SetProperties and inadvertently
// change it.
InitWorkDir(ppl, &prg, NULL);
}
if (prg.achWorkDir[0]) {
cb = lstrunquotefnameA(szTmp, prg.achWorkDir, ARRAYSIZE(szTmp), TRUE);
if (szTmp[1] == ':') {
WriteFile(hFile, szTmp, 2, &dwBytes, NULL);
WriteFile(hFile, szCRLF, ARRAYSIZE(szCRLF)-1, &dwBytes, NULL);
}
WriteFile(hFile, szCD, sizeof(szCD)-1, &dwBytes, NULL);
WriteFile(hFile, szTmp, cb, &dwBytes, NULL);
WriteFile(hFile, szCRLF, sizeof(szCRLF)-1, &dwBytes, NULL);
}
// We now always CALL the cmd-line, in case it's a batch file.
// If it isn't, no biggie, because command.com is smart enough
// to ignore it.
WriteFile(hFile, szCall, sizeof(szCall)-1, &dwBytes, NULL);
// If the properties we have are ones *we* created in the
// PIF dir, and it looks like the application name passed to
// PifMgr_OpenProperties is a "qualified" pathname, then we'll use
// that instead of the path stored in the PIF, since the app
// might have moved since *we* created the PIF.
if ((ppl->flProp & PROP_PIFDIR) &&
(ppl->szPathName[0] == TEXT('\\') ||
ppl->szPathName[0] && ppl->szPathName[1] == TEXT(':'))) {
// We're making this call not because ppl->szPathName
// is quoted (it shouldn't be), but because it could still
// be a long filename, so translate it.
CHAR achPathName[ ARRAYSIZE(ppl->szPathName) ];
PifMgr_WCtoMBPath( ppl->szPathName, achPathName, ARRAYSIZE(achPathName) );
i = lstrunquotefnameA(szTmp, achPathName, ARRAYSIZE(szTmp), -1);
}
else {
// As for the thing stored in the PIF, now *that* could
// both long and quoted. Take care of it now.
i = lstrunquotefnameA(szTmp, prg.achCmdLine, ARRAYSIZE(szTmp), TRUE);
}
// NOTE: There is an obscure case where the preceding call
// to lstrunquotefname can fail, returning i == 0, even though
// WinOldAp already verified the app exists. That case is when
// the app name is NOT fully-qualified, so it exists somewhere
// on the PATH, but NOT in the current directory, and the app
// name is an LFN. Because lstrunquotefname must call INT 21h,
// function 7160h, subfunction 1 (NAMTRN_DO83QUERY), IFSMGR must
// find the equivalent 8.3 name for the LFN app name, but all
// IFSMGR has to work with is the current directory, and that's
// not where the app is, so the INT 21h fails, returning error
// #3 (ERROR_PATH_NOT_FOUND).
//
// To solve, we could do another PATH search for the app file,
// via OpenFileEx; if found, it would return the fully-qualifed
// long-file-name of the app, in the OEM char set, which we
// could then perform NameTrans on, to get full 8.3. Yuck! -JP
// If there are any arguments in the PIF, find them
// and append them, giving PREFERENCE to any args that WINOLDAP
// specifically associated with this instance of the app.
if (ppl->lpArgs) { // any associated args?
j = lstrlen(ppl->lpArgs);
if (j) {
szTmp[i++] = ' ';
if (ppl->lpArgs[j-1] == TEXT('\r'))
j--;
{
CHAR achArgs[ ARRAYSIZE(ppl->lpArgs) ];
WideCharToMultiByte( CP_ACP, 0,
ppl->lpArgs, -1,
achArgs, ARRAYSIZE(achArgs),
NULL, NULL );
lstrcpynA(szTmp+i, achArgs, min(sizeof(szTmp)-i,(unsigned)j+1));
}
}
} else {
j = lstrskipfnameA(prg.achCmdLine);
if (prg.achCmdLine[j])
lstrcpynA(szTmp+i, prg.achCmdLine+j, ARRAYSIZE(szTmp)-i);
}
WriteFile(hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL);
WriteFile(hFile, szCRLF, sizeof(szCRLF)-1, &dwBytes, NULL);
// If we paused above to ask for a disk, we should pause
// again to ask them to remove the disk. We won't actually
// emit a PAUSE though unless close-on-exit is set, since
// WIN.COM should already pause for them when the cursor isn't
// at 0,0.
if (fPause) {
WriteFile(hFile, szEcho, sizeof(szEcho)-1, &dwBytes, NULL);
szTmp[0] = TEXT('\0');
LoadStringA(g_hinst, IDS_DISKREMOVE, szTmp, ARRAYSIZE(szTmp));
WriteFile(hFile, szTmp, lstrlenA(szTmp), &dwBytes, NULL);
if (prg.flPrg & PRG_CLOSEONEXIT)
WriteFile(hFile, szPause, sizeof(szPause)-1, &dwBytes, NULL);
else
WriteFile(hFile, szCRLF, sizeof(szCRLF)-1, &dwBytes, NULL);
}
}
}
CloseHandle(hFile);
}
if (pbData)
EVAL(LocalFree(pbData) == NULL);
return fSuccess;
}
/** PifMgr_CloseProperties - close property info for application
*
* INPUT
* hProps = handle to properties
* flOpt = CLOSEPROPS_DISCARD to abandon cached PIF data, otherwise save it
*
* OUTPUT
* NULL if successful, otherwise hProps is returned as given
*/
HANDLE WINAPI PifMgr_CloseProperties(HANDLE hProps, UINT flOpt)
{
PPROPLINK ppl;
FunctionName(PifMgr_CloseProperties);
if (!(ppl = ValidPropHandle(hProps)))
return hProps;
// When discarding on a close, set the SKIPPIF flag, so that the
// flush code won't say "oh, not only should I throw away my current
// set of data, but I should read in clean data" -- new data is no use
// since the caller is closing.
if (flOpt & CLOSEPROPS_DISCARD)
ppl->flProp |= PROP_SKIPPIF;
if (ppl->flProp & PROP_DIRTY) { // this redundant check added
// to avoid making FlushPIFData PRELOAD -JTP
// Note that we avoid calling FlushPIFData if INHIBITPIF is set,
// since FlushPIFData will just return a fake TRUE result anyway.
// But we don't want to be fooled, we want to make sure the block
// gets unlocked now.
if ((ppl->flProp & PROP_INHIBITPIF) || !FlushPIFData(ppl, (flOpt & CLOSEPROPS_DISCARD))) {
// If FlushPIFData failed, then if we still have an outstanding
// dirty lock, force the data to become unlocked, by clearing the
// dirty flag in the middle of a pair otherwise pointless lock/unlock
// calls (because that's the nice, clean way to do it!)
if (ppl->flProp & PROP_DIRTYLOCK) {
ppl->cLocks++;
ppl->flProp &= ~PROP_DIRTY;
ppl->cLocks--;
}
}
}
if (ppl->lpPIFData) {
LocalFree(ppl->lpPIFData);
ppl->lpPIFData = NULL;
}
if (ppl->hPIF != INVALID_HANDLE_VALUE)
CloseHandle(ppl->hPIF);
// Unlink from the global list
if (ppl->pplPrev)
ppl->pplPrev->pplNext = ppl->pplNext;
else
g_pplHead = ppl->pplNext;
if (ppl->pplNext)
ppl->pplNext->pplPrev = ppl->pplPrev;
LocalFree(ppl);
return NULL;
}
/** ValidPropHandle - verify handle
*
* INPUT
* hProps = handle to properties
*
* OUTPUT
* pointer to prop, NULL otherwise
*/
PPROPLINK ValidPropHandle(HANDLE hProps)
{
FunctionName(ValidPropHandle);
if (!hProps ||
(HANDLE)hProps > g_offHighestPropLink ||
((PPROPLINK)hProps)->iSig != PROP_SIG) {
ASSERTFAIL();
return NULL;
}
return (PPROPLINK)hProps;
}
/** ResizePIFData - verify handle and resize PIF data
*
* INPUT
* ppl -> property
* cbResize = bytes to resize PIF data by
*
* OUTPUT
* previous size of PIF data if successful, -1 if not
*
* on success, the PIF data is returned LOCKED, so successful
* ResizePIFData calls should be matched with UnlockPIFData calls.
*/
int ResizePIFData(PPROPLINK ppl, INT cbResize)
{
INT cbOld, cbNew;
void *lpNew;
BOOL fInitStdHdr = FALSE;
FunctionName(ResizePIFData);
ASSERTTRUE(cbResize != 0);
// Cope with empty or old PIF files
cbOld = ppl->cbPIFData;
cbNew = ppl->cbPIFData + cbResize;
if ((cbNew < cbOld) == (cbResize > 0))
return -1; // underflow/overflow
if (!ppl->lpPIFData && cbOld == 0) {
if (cbNew >= sizeof(STDPIF) + sizeof(PIFEXTHDR))
fInitStdHdr = TRUE;
lpNew = LocalAlloc(LPTR, cbNew);
}
else
{
if (cbOld == sizeof(STDPIF))
{
fInitStdHdr = TRUE;
cbOld += sizeof(PIFEXTHDR);
cbNew += sizeof(PIFEXTHDR);
}
lpNew = LocalReAlloc( ppl->lpPIFData, cbNew, LMEM_MOVEABLE|LMEM_ZEROINIT);
}
if (lpNew) {
ppl->cbPIFData = cbNew;
ppl->lpPIFData = (LPPIFDATA)lpNew;
ppl->cLocks++;
if (fInitStdHdr) {
lstrcpyA(ppl->lpPIFData->stdpifext.extsig, szSTDHDRSIG);
ppl->lpPIFData->stdpifext.extnxthdrfloff = LASTHDRPTR;
ppl->lpPIFData->stdpifext.extfileoffset = 0x0000;
ppl->lpPIFData->stdpifext.extsizebytes = sizeof(STDPIF);
}
return cbOld;
}
return -1;
}
/** GetPIFData - read PIF data back from PIF
*
* INPUT
* ppl -> property
* fLocked == TRUE to return data locked, FALSE unlocked
*
* OUTPUT
* TRUE if succeeded, FALSE if not
*/
BOOL GetPIFData(PPROPLINK ppl, BOOL fLocked)
{
DWORD dwOff;
LPTSTR pszOpen;
BOOL fSuccess = FALSE;
FunctionName(GetPIFData);
// Since we're going to (re)load the property data now, reset
// the current size, so that ResizePIFData will resize it from zero
ppl->cbPIFData = 0;
// If SKIPPIF is set (eg, by PifMgr_OpenProperties), then don't
// try to open anything (since PifMgr_OpenProperties already tried!),
if (ppl->hPIF == INVALID_HANDLE_VALUE && !(ppl->flProp & PROP_SKIPPIF)) {
pszOpen = g_szDefaultPIF;
if (!(ppl->flProp & PROP_DEFAULTPIF))
pszOpen = ppl->ofPIF.szPathName;
ppl->hPIF = CreateFile( pszOpen,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
}
if (ppl->hPIF == INVALID_HANDLE_VALUE) {
// The following warning is disabled because the presence of
// the dialog box got WINOLDAP stuck in an infinite message loop -JTP
InitProperties(ppl, fLocked);
goto Exit;
}
dwOff = SetFilePointer(ppl->hPIF, 0, NULL, FILE_END);
if (dwOff >= sizeof(STDPIF)) {
ppl->flProp |= PROP_REGEN;
if (ResizePIFData(ppl, dwOff) != -1) {
SetFilePointer(ppl->hPIF, 0, NULL, FILE_BEGIN);
if (ReadFile( ppl->hPIF, ppl->lpPIFData,
ppl->cbPIFData, &ppl->cbPIFData, NULL ))
{
// Can't be dirty anymore, 'cause we just read the PIF back in
ppl->flProp &= ~PROP_DIRTY;
if (ppl->flProp & PROP_DEFAULTPIF) {
WideCharToMultiByte( CP_ACP, 0,
ppl->szPathName+ppl->iFileName,
-1,
ppl->lpPIFData->stdpifdata.appname,
ARRAYSIZE(ppl->lpPIFData->stdpifdata.appname),
NULL, NULL
);
PifMgr_WCtoMBPath( ppl->szPathName,
ppl->lpPIFData->stdpifdata.startfile,
ARRAYSIZE(ppl->lpPIFData->stdpifdata.startfile)
);
// I don't think this is generally worth dirtying the
// property info for, because otherwise every app that used
// _DEFAULT.PIF initially would get its own PIF file created
// later; PIF file creation should only take place when
// substantive changes have been made
// ppl->flProp |= PROP_DIRTY;
}
// If we're not dealing with an enhanced PIF, then we
// go to the various INI files to retrieve DOS app defaults
if (!GetGroupData(ppl, szWENHHDRSIG40, NULL, NULL)) {
GetINIData();
}
// If we're not dealing with a new NT/UNICODE PIF, then
// we add a new section so it's ALWAYS there when we're
// UNICODE enabled.
if (!GetGroupData(ppl, szWNTHDRSIG40, NULL, NULL)) {
VERIFYTRUE(AddGroupData(ppl, szWNTHDRSIG40, NULL, sizeof(WNTPIF40)));
}
// If we're not dealing with a NT PIF, then
// we add the NT sections so it's ALWAYS there when we're
// running on NT.
if (!GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL)) {
LPWNTPIF31 lpnt31;
VERIFYTRUE(AddGroupData(ppl, szWNTHDRSIG31, NULL, sizeof(WNTPIF31)));
if (NULL != (lpnt31 = GetGroupData(ppl, szWNTHDRSIG31, NULL, NULL))) {
lstrcpyA( lpnt31->nt31Prop.achConfigFile, NT_CONFIG_FILE );
lstrcpyA( lpnt31->nt31Prop.achAutoexecFile, NT_AUTOEXEC_FILE );
}
}
if (!fLocked)
ppl->cLocks--; // UnlockPIFData(ppl);
fSuccess++;
}
}
else
ASSERTFAIL();
ppl->flProp &= ~PROP_REGEN;
}
CloseHandle(ppl->hPIF);
ppl->hPIF = INVALID_HANDLE_VALUE;
// As long as IGNOREPIF isn't set, clear SKIPPIF, because even if we
// already knew the PIF didn't exist on *this* call, one may be created
// (by someone else) by the next time we're called
Exit:
if (!(ppl->flProp & PROP_IGNOREPIF))
ppl->flProp &= ~PROP_SKIPPIF;
return fSuccess;
}
/** FlushPIFData - write dirty PIF data back to PIF
*
* INPUT
* ppl -> property
* fDiscard == TRUE to discard dirty data, FALSE to keep it
*
* OUTPUT
* TRUE if succeeded, FALSE if not
*
* NOTES
* We must first check the PROPLINK and see if the DONTWRITE bit has
* been set, in which case we have to fail the flush. Once DONTWRITE is
* set in a PROPLINK, it will never be cleared, unless the caller
* specifies fDiscard == TRUE to reload the data. This is BY DESIGN (ie,
* a UI compromise). How does DONTWRITE get set? By someone else
* having previously (and successfully) done a flush to the same PIF; at
* that point in time, we will look for all other properties that refer to
* the same file, and set their DONTWRITE bit. What about PROPLINKs that
* are created later? They're ok, they don't get DONTWRITE set until
* the above sequence takes place during their lifetime.
*/
BOOL FlushPIFData(PPROPLINK ppl, BOOL fDiscard)
{
UINT u;
BOOL fSuccess = FALSE;
FunctionName(FlushPIFData);
// If nothing dirty, nothing to do
if (!(ppl->flProp & PROP_DIRTY) || (ppl->flProp & PROP_INHIBITPIF))
return TRUE; // ie, success
// If discarding, then clear PROP_DIRTY and reload the data
if (fDiscard) {
ppl->flProp &= ~(PROP_DIRTY | PROP_DONTWRITE);
return GetPIFData(ppl, FALSE);
}
if (ppl->flProp & PROP_DONTWRITE)
return fSuccess; // ie, FALSE (error)
if (!ppl->lpPIFData)
return fSuccess; // ie, FALSE (error)
ppl->cLocks++;
// If we created properties without opening a file, it may have
// been because normal PIF search processing was overridden by the
// presence of a WIN.INI entry; if that entry is still there,
// then our data is not in sync with any existing file, nor is there
// any point in creating a new file as long as that entry exists. We
// need to consider prompting the user as to whether he really wants
// that WIN.INI entry, so that it's clear what the heck is going on
if (ppl->flProp & PROP_IGNOREPIF) {
HANDLE hProps;
ppl->ckbMem = GetProfileInt(apszAppType[APPTYPE_PIF]+1, ppl->szPathName+ppl->iFileName, -1);
if (ppl->ckbMem != -1)
goto Exit;
// The WIN.INI entry apparently went away, so let's re-attempt to
// open the properties that we should have obtained in the first
// place. Assuming success, we will copy our entire block on top of
// them (thereby flushing it), and also copy their PIF name to our
// PIF name and their PIF flags to our PIF flags, so that future
// flushes are of the more normal variety
hProps = PifMgr_OpenProperties(ppl->ofPIF.szPathName, NULL, 0, OPENPROPS_RAWIO);
if (hProps) {
ppl->flProp &= ~(PROP_IGNOREPIF | PROP_SKIPPIF);
ppl->flProp |= ((PPROPLINK)hProps)->flProp & (PROP_IGNOREPIF | PROP_SKIPPIF);
lstrcpy(ppl->ofPIF.szPathName, ((PPROPLINK)hProps)->ofPIF.szPathName);
if (PifMgr_SetProperties(hProps, NULL, ppl->lpPIFData, ppl->cbPIFData, SETPROPS_RAWIO) == ppl->cbPIFData) {
fSuccess++;
ppl->flProp &= ~(PROP_DIRTY | PROP_TRUNCATE);
}
PifMgr_CloseProperties(hProps, CLOSEPROPS_NONE);
}
goto Exit;
}
// Disable annoying critical error popups (NO MORE GOTOS PAST HERE PLEASE)
u = SetErrorMode(SEM_FAILCRITICALERRORS);
ppl->hPIF = CreateFile( ppl->ofPIF.szPathName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL );
// If we couldn't open the file, then the presumption is that the
// app didn't have a PIF (or did but someone but someone deleted it),
// and so we use the name we constructed during PifMgr_OpenProperties in case
// they ever opted to save new settings (which they obviously have done!)
// 28-Feb-95: If the PIF did exist at one time (meaning NOCREATPIF is
// set), then don't recreate it; somebody's trying to delete their own
// PIF, so let them. -JTP
if ((ppl->hPIF != INVALID_HANDLE_VALUE) && (GetLastError()!=ERROR_FILE_EXISTS)) {
if (!(ppl->flProp & PROP_NOCREATEPIF))
SetFilePointer( ppl->hPIF, 0, NULL, FILE_BEGIN );
// If the create succeeded, we're no longer using the default PIF
if (ppl->hPIF != INVALID_HANDLE_VALUE) {
ppl->flProp |= PROP_NOCREATEPIF;
ppl->flProp &= ~(PROP_TRUNCATE | PROP_NOPIF | PROP_DEFAULTPIF);
}
}
// If either the open or the create succeeded, write the PIF data out now
if (ppl->hPIF != INVALID_HANDLE_VALUE) {
PPROPLINK pplEnum;
DWORD dwDummy;
WriteFile( ppl->hPIF, (LPCVOID)ppl->lpPIFData,
ppl->cbPIFData, &dwDummy, NULL );
if (ppl->flProp & PROP_TRUNCATE)
WriteFile(ppl->hPIF, (LPCVOID)ppl->lpPIFData, 0, &dwDummy, NULL );
CloseHandle(ppl->hPIF);
ppl->hPIF = INVALID_HANDLE_VALUE;
ppl->flProp &= ~(PROP_DIRTY | PROP_TRUNCATE);
fSuccess++;
// Here's where we want to check for other active PROPLINKs using the
// same PIF. For each one found, set its DONTWRITE bit.
pplEnum = NULL;
while (NULL != (pplEnum = (PPROPLINK)EnumProperties(pplEnum))) {
if (lstrcmpi(ppl->ofPIF.szPathName, pplEnum->ofPIF.szPathName) == 0) {
if (pplEnum != ppl)
pplEnum->flProp |= PROP_DONTWRITE;
}
}
}
// Re-enable annoying critical error popups
SetErrorMode(u);
Exit:
ppl->cLocks--;
return fSuccess;
}
/** AddEnhancedData - create enhanced section(s) of PIF data
*
* INPUT
* ppl -> property
*
* OUTPUT
* lpenh or NULL
*/
LPWENHPIF40 AddEnhancedData(PPROPLINK ppl, LPW386PIF30 lp386)
{
PROPPRG prg;
PROPTSK tsk;
PROPVID vid;
PROPKBD kbd;
PROPMSE mse;
PROPFNT fnt;
PROPWIN win;
PROPENV env;
void *aDataPtrs[NUM_DATA_PTRS];
LPWENHPIF40 lpenh = NULL;
FunctionName(AddEnhancedData);
// Get copies of pre-enhanced and/or default settings first,
// and do them all *before* doing the AddGroupData, because the
// functions' behavior will change once the enhanced section is added;
// in addition, zero those strucs that contain strings, since lstrcpy()
// may initialize a minimum of 1 byte, leaving garbage in the rest.
BZero(&prg, sizeof(prg));
BZero(&fnt, sizeof(fnt));
BZero(&win, sizeof(win));
BZero(&env, sizeof(env));
BZero(aDataPtrs, sizeof(aDataPtrs));
aDataPtrs[ LP386_INDEX ] = (LPVOID)lp386;
GetPrgData(ppl, aDataPtrs, &prg, sizeof(prg), GETPROPS_NONE);
GetTskData(ppl, aDataPtrs, &tsk, sizeof(tsk), GETPROPS_NONE);
GetVidData(ppl, aDataPtrs, &vid, sizeof(vid), GETPROPS_NONE);
GetKbdData(ppl, aDataPtrs, &kbd, sizeof(kbd), GETPROPS_NONE);
GetMseData(ppl, aDataPtrs, &mse, sizeof(mse), GETPROPS_NONE);
GetFntData(ppl, aDataPtrs, &fnt, sizeof(fnt), GETPROPS_NONE);
GetWinData(ppl, aDataPtrs, &win, sizeof(win), GETPROPS_NONE);
GetEnvData(ppl, aDataPtrs, &env, sizeof(env), GETPROPS_NONE);
if (AddGroupData(ppl, szWENHHDRSIG40, NULL, sizeof(WENHPIF40))) {
if (NULL != (lpenh = GetGroupData(ppl, szWENHHDRSIG40, NULL, NULL))) {
lpenh->dwEnhModeFlagsProp = prg.dwEnhModeFlags;
lpenh->dwRealModeFlagsProp = prg.dwRealModeFlags;
lstrcpyA(lpenh->achOtherFileProp, prg.achOtherFile);
lstrcpyA(lpenh->achIconFileProp, prg.achIconFile);
lpenh->wIconIndexProp = prg.wIconIndex;
lpenh->tskProp = tsk;
lpenh->vidProp = vid;
lpenh->kbdProp = kbd;
lpenh->mseProp = mse;
lpenh->fntProp = fnt;
lpenh->winProp = win;
lpenh->envProp = env;
lpenh->wInternalRevision = WENHPIF40_VERSION;
}
}
return lpenh;
}
/** AddGroupData - add NEW property group to PIF data
*
* INPUT
* ppl -> property
* lpszGroup -> name of new group
* lpGroup -> new group record (if NULL, then group data is zero-filled)
* cbGroup == size of new group record
*
* OUTPUT
* TRUE if successful, FALSE if not
*/
BOOL AddGroupData(PPROPLINK ppl, LPCSTR lpszGroup, LPCVOID lpGroup, int cbGroup)
{
INT cbOld;
LPPIFEXTHDR lpph;
FunctionName(AddGroupData);
if ((cbOld = ResizePIFData(ppl, cbGroup+sizeof(PIFEXTHDR))) != -1) {
lpph = (LPPIFEXTHDR)LPPIF_FIELDOFF(stdpifext);
while ((DWORD_PTR)lpph <= (DWORD_PTR)LPPIF_OFF(cbOld - sizeof(PIFEXTHDR)) &&
(DWORD_PTR)lpph >= (DWORD_PTR)LPPIF_FIELDOFF(stdpifext)) {
if (lpph->extnxthdrfloff == LASTHDRPTR) {
lpph->extnxthdrfloff = (WORD) cbOld;
lpph = (LPPIFEXTHDR)LPPIF_OFF(cbOld);
lstrcpynA(lpph->extsig, lpszGroup, sizeof(lpph->extsig));
lpph->extnxthdrfloff = LASTHDRPTR;
lpph->extfileoffset = (INT)(cbOld + sizeof(PIFEXTHDR));
lpph->extsizebytes = (WORD) cbGroup;
if (lpGroup) {
hmemcpy((LPBYTE)LPPH_OFF(sizeof(PIFEXTHDR)), lpGroup, cbGroup);
ppl->flProp |= PROP_DIRTY;
}
break;
}
lpph = (LPPIFEXTHDR)LPPIF_OFF(lpph->extnxthdrfloff);
}
ppl->cLocks--;
return TRUE;
}
ASSERTFAIL();
return FALSE;
}
/** RemoveGroupData - remove EXISTING property group from PIF data
*
* INPUT
* ppl -> property
* lpszGroup -> name of group
*
* OUTPUT
* TRUE if successful, FALSE if not
*/
BOOL RemoveGroupData(PPROPLINK ppl, LPCSTR lpszGroup)
{
INT cbGroup, fSuccess;
LPBYTE lpGroup;
WORD extnxthdrfloff;
LPPIFEXTHDR lpph, lpphGroup;
FunctionName(RemoveGroupData);
ppl->cLocks++;
fSuccess = FALSE;
if (NULL != (lpGroup = GetGroupData(ppl, lpszGroup, &cbGroup, &lpphGroup))) {
// Removing groups is a bit tedious, so here goes....
// First, we will walk all the headers, attempting to find the
// one that points to the one we're about to remove, and point it
// to the next one, and at the same time adjust all file offsets that
// equal or exceed the offsets of either the outgoing data or its
// header.
lpph = (LPPIFEXTHDR)LPPIF_FIELDOFF(stdpifext);
while ((DWORD_PTR)lpph <= (DWORD_PTR)LPPIF_OFF(ppl->cbPIFData - sizeof(PIFEXTHDR)) &&
(DWORD_PTR)lpph >= (DWORD_PTR)LPPIF_FIELDOFF(stdpifext)) {
extnxthdrfloff = lpph->extnxthdrfloff;
if ((DWORD_PTR)LPPH_OFF(lpph->extfileoffset) >= (DWORD_PTR)lpGroup)
lpph->extfileoffset -= (WORD) cbGroup;
if (lpphGroup) {
if ((DWORD_PTR)LPPH_OFF(lpph->extfileoffset) >= (DWORD_PTR)lpphGroup)
lpph->extfileoffset -= sizeof(PIFEXTHDR);
if ((DWORD_PTR)LPPH_OFF(lpph->extnxthdrfloff) == (DWORD_PTR)lpphGroup)
extnxthdrfloff = lpph->extnxthdrfloff = lpphGroup->extnxthdrfloff;
}
if (extnxthdrfloff == LASTHDRPTR)
break;
if ((DWORD_PTR)LPPH_OFF(lpph->extnxthdrfloff) >= (DWORD_PTR)lpGroup)
lpph->extnxthdrfloff -= (WORD) cbGroup;
if (lpphGroup)
if ((DWORD_PTR)LPPH_OFF(lpph->extnxthdrfloff) >= (DWORD_PTR)lpphGroup)
lpph->extnxthdrfloff -= sizeof(PIFEXTHDR);
lpph = (LPPIFEXTHDR)LPPIF_OFF(extnxthdrfloff);
}
// Next, move everything up over the data, then adjust lpph as
// needed and move everything up over the header (this must be done
// in two discrete steps, because we shouldn't assume anything
// about the data's location relative to its header).
hmemcpy(lpGroup, (LPBYTE)lpGroup+cbGroup,
(DWORD_PTR)LPPIF_OFF(ppl->cbPIFData) - (DWORD_PTR)((LPBYTE)lpGroup+cbGroup));
if (lpphGroup) {
if ((DWORD_PTR)lpphGroup >= (DWORD_PTR)((LPBYTE)lpGroup+cbGroup))
lpphGroup -= cbGroup;
hmemcpy(lpphGroup, lpphGroup+1,
(DWORD_PTR)LPPIF_OFF(ppl->cbPIFData) - (DWORD_PTR)((LPBYTE)lpphGroup+1+cbGroup));
cbGroup += sizeof(PIFEXTHDR);
}
ResizePIFData(ppl, -cbGroup);
ppl->flProp |= PROP_DIRTY | PROP_TRUNCATE;
ppl->cLocks--;
}
ppl->cLocks--;
return fSuccess;
}
/** GetGroupData - get ptr to property group (by name)
*
* INPUT
* ppl -> property (assumes it is LOCKED)
* lpszGroup -> property group; may be one of the following:
* "WINDOWS 286 3.0"
* "WINDOWS 386 3.0"
* "WINDOWS PIF.400"
* or any other group name that is the name of a valid PIF extension.
* if NULL, then *lpcbGroup is a 0-based index of the group we are looking for
* lpcbGroup -> where to return size of group data (NULL if not)
* lplpph -> where to return ptr to pif extension header, if any (NULL if not)
*
* OUTPUT
* Returns ptr to property group info, NULL if not found
*/
void *GetGroupData(PPROPLINK ppl, LPCSTR lpszGroup,
LPINT lpcbGroup, LPPIFEXTHDR *lplpph)
{
BOOL fFixMe;
LPPIFEXTHDR lpph;
FunctionName(GetGroupData);
if (!ppl->lpPIFData)
return NULL;
lpph = (LPPIFEXTHDR)LPPIF_FIELDOFF(stdpifext);
while ((DWORD_PTR)lpph <= (DWORD_PTR)LPPIF_OFF(ppl->cbPIFData-sizeof(PIFEXTHDR)) &&
(DWORD_PTR)lpph >= (DWORD_PTR)LPPIF_FIELDOFF(stdpifext)) {
// PIFEDIT 3.x can trash the first byte of our extended portion
// (generally with a zero), so try to recover by stuffing the first
// character of the group we're looking for into the signature;
// if the rest of the signature matches, great, if it doesn't, then
// re-zero it.
if (!lpszGroup) {
// searching by index *lpcbGroup
if (!(*lpcbGroup)--) {
if (lplpph)
*lplpph = lpph;
*lpcbGroup = lpph->extsizebytes;
return lpph;
}
}
else {
if (FALSE != (fFixMe = !lpph->extsig[0])) // attempt to fix
lpph->extsig[0] = *lpszGroup;
if (lstrcmpiA(lpph->extsig, lpszGroup) == 0) {
if (lplpph)
*lplpph = lpph;
if (lpcbGroup)
*lpcbGroup = lpph->extsizebytes;
if (lpph->extfileoffset >= (WORD)ppl->cbPIFData) {
ASSERTFAIL();
return NULL;
}
return (LPBYTE)LPPIF_OFF(lpph->extfileoffset);
}
if (fFixMe) // fix failed (this time anyway)
lpph->extsig[0] = 0;
}
if (lpph->extnxthdrfloff == LASTHDRPTR)
break;
lpph = (LPPIFEXTHDR)LPPIF_OFF(lpph->extnxthdrfloff);
}
// If we didn't get anywhere, check if this is a "really old" PIF;
// ie, one without any headers; if so, then if all they were asking for
// was the old stuff, return it
if (ppl->cbPIFData == sizeof(STDPIF) && lpszGroup) {
if (lstrcmpiA(szSTDHDRSIG, lpszGroup) == 0) {
if (lplpph)
*lplpph = NULL;
if (lpcbGroup)
*lpcbGroup = sizeof(STDPIF);
return ppl->lpPIFData;
}
}
return NULL;
}
/** AppWizard - call the AppWizard CPL (appwiz.cpl)
*/
TCHAR c_szAPPWIZ[] = TEXT("appwiz.cpl");
CHAR c_szAppWizard[] = "AppWizard";
typedef DWORD (WINAPI *LPAPPWIZARD)(HWND hwnd, HANDLE i, UINT ui);
UINT WINAPI AppWizard(HWND hwnd, HANDLE hProps, UINT action)
{
DWORD err = 42;
LPAPPWIZARD XAppWizard;
HINSTANCE hAppWizard;
hAppWizard = LoadLibrary(c_szAPPWIZ);
if (hAppWizard)
{
if (NULL != (XAppWizard = (LPAPPWIZARD)GetProcAddress(hAppWizard, c_szAppWizard)))
{
err = XAppWizard( hwnd, hProps, action );
}
FreeLibrary((HINSTANCE)hAppWizard);
}
return (UINT)err;
}
Reference in a new issue View git blame Copy permalink