1710 lines
40 KiB
C
1710 lines
40 KiB
C
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ochelper.c
|
|
|
|
Abstract:
|
|
|
|
Helper/callback routines, available to plug-in components
|
|
when processing interface routine calls.
|
|
|
|
Author:
|
|
|
|
Ted Miller (tedm) 13-Sep-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
|
|
//
|
|
// Window handle of wizard dialog. Set when the OC Manager client
|
|
// calls OcRememberWizardDialogHandle.
|
|
//
|
|
HWND WizardDialogHandle;
|
|
|
|
VOID
|
|
OcHelperShowHideWizardPage(
|
|
IN PVOID OcManagerContext,
|
|
IN BOOL bShow
|
|
)
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
if (p->Callbacks.ShowHideWizardPage)
|
|
{
|
|
// If we have a callback, hide the wizard.
|
|
p->Callbacks.ShowHideWizardPage(bShow);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
OcHelperTickGauge(
|
|
IN PVOID OcManagerContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function used while processing the OC_COMPLETE_INSTALLATION Interface function
|
|
to step the progress gauge being run by the OC Manager.
|
|
Ignored at other times.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
pOcTickSetupGauge(((PHELPER_CONTEXT)OcManagerContext)->OcManager);
|
|
}
|
|
|
|
|
|
VOID
|
|
#ifdef UNICODE
|
|
OcHelperSetProgressTextW(
|
|
#else
|
|
OcHelperSetProgressTextA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR Text
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function used while processing the OC_COMPLETE_INSTALLATION Interface function
|
|
to change the text associated with the progress gauge being run by
|
|
the OC Manager. Ignored at other times.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
Text - Supplies the text for the progress gauge. The component should try to
|
|
respect the current language parameters established by OC_SET_LANGUAGE.
|
|
The OC Manager will make a copy of the string and truncate it as necessary.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
|
|
#ifdef DEBUGPERFTRACE
|
|
static DWORD lasttickcount = 0;
|
|
static DWORD currenttickcount = 0;
|
|
static DWORD diff, lastdiff;
|
|
|
|
if (!lasttickcount)
|
|
lasttickcount = GetTickCount();
|
|
|
|
lasttickcount = currenttickcount;
|
|
currenttickcount = GetTickCount();
|
|
lastdiff = diff;
|
|
diff = currenttickcount - lasttickcount;
|
|
TRACE(( TEXT("SetProgressText at %d (last = %d, diff = %d, last diff = %d)\n"), currenttickcount, lasttickcount, diff, lastdiff ));
|
|
if (diff > 1000*3) {
|
|
WRN(( TEXT("It's been > 3 seconds since the last tick count update...the user is getting impatient.\n") ));
|
|
}
|
|
|
|
#endif
|
|
|
|
if(p->ProgressTextWindow) {
|
|
SetWindowText(p->ProgressTextWindow,Text);
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
VOID
|
|
OcHelperSetProgressTextA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR Text
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI version of OcHelperSetProgressText().
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
LPCWSTR p;
|
|
|
|
if(p = pSetupAnsiToUnicode(Text)){
|
|
OcHelperSetProgressTextW(OcManagerContext,p);
|
|
pSetupFree(p);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
UINT
|
|
_OcHelperSetPrivateData(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCVOID Name,
|
|
IN PVOID Data,
|
|
IN UINT Size,
|
|
IN UINT Type,
|
|
IN BOOL IsNativeCharWidth
|
|
)
|
|
{
|
|
PHELPER_CONTEXT HelperContext;
|
|
DWORD rc;
|
|
DWORD Disposition;
|
|
HKEY hKey;
|
|
LONG id;
|
|
|
|
HelperContext = OcManagerContext;
|
|
|
|
//
|
|
// Fetch the component id. If we're processing an interface routine
|
|
// then use the component id of the active component. Otherwise
|
|
// resort to the component id stored in the helper context.
|
|
//
|
|
if(HelperContext->OcManager->CurrentComponentStringId == -1) {
|
|
id = HelperContext->ComponentStringId;
|
|
} else {
|
|
id = HelperContext->OcManager->CurrentComponentStringId;
|
|
}
|
|
|
|
rc = RegCreateKeyEx(
|
|
HelperContext->OcManager->hKeyPrivateData,
|
|
pSetupStringTableStringFromId(HelperContext->OcManager->ComponentStringTable,id),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_VOLATILE,
|
|
KEY_SET_VALUE,
|
|
NULL,
|
|
&hKey,
|
|
&Disposition
|
|
);
|
|
|
|
if(rc == NO_ERROR) {
|
|
if(IsNativeCharWidth) {
|
|
rc = RegSetValueEx(hKey,Name,0,Type,Data,Size);
|
|
} else {
|
|
rc = RegSetValueExA(hKey,Name,0,Type,Data,Size);
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
UINT
|
|
#ifdef UNICODE
|
|
OcHelperSetPrivateDataW(
|
|
#else
|
|
OcHelperSetPrivateDataA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR Name,
|
|
IN PVOID Data,
|
|
IN UINT Size,
|
|
IN UINT Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function to set a named datum that can then be retrieved later
|
|
by the component or by any other component, via the GetPrivateData
|
|
helper routine.
|
|
|
|
This routine can be called at any time.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
Name - Supplies a name for the datum. If a datum with this name
|
|
already exists for the component, it is overwritten.
|
|
|
|
Data - Supplies the data itself. The OC Manager makes a copy of the data
|
|
so the component need not ensure that this buffer remains valid.
|
|
|
|
Size - Supplies the size in bytes of the data.
|
|
|
|
Type - Supplies the type of the data. Components should use the standard registry
|
|
type names (REG_SZ, REG_BINARY, etc.) to facilitate inter-component
|
|
data sharing.
|
|
|
|
Return Value:
|
|
|
|
Win32 error code indicating outcome; NO_ERROR means success.
|
|
|
|
--*/
|
|
|
|
{
|
|
return(_OcHelperSetPrivateData(OcManagerContext,Name,Data,Size,Type,TRUE));
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
UINT
|
|
OcHelperSetPrivateDataA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR Name,
|
|
IN PVOID Data,
|
|
IN UINT Size,
|
|
IN UINT Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI version of OcHelperSetPrivateData().
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
return(_OcHelperSetPrivateData(OcManagerContext,Name,Data,Size,Type,FALSE));
|
|
}
|
|
#endif
|
|
|
|
|
|
UINT
|
|
_OcHelperGetPrivateData(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR ComponentId, OPTIONAL
|
|
IN LPCVOID Name,
|
|
OUT PVOID Data, OPTIONAL
|
|
IN OUT PUINT Size,
|
|
OUT PUINT Type,
|
|
IN BOOL IsNativeCharWidth
|
|
)
|
|
{
|
|
PHELPER_CONTEXT HelperContext;
|
|
PCTSTR ComponentName;
|
|
DWORD rc;
|
|
DWORD Disposition;
|
|
HKEY hKey;
|
|
LONG id;
|
|
|
|
HelperContext = OcManagerContext;
|
|
|
|
//
|
|
// Figure out the name of the component that owns the data.
|
|
//
|
|
if(ComponentId) {
|
|
ComponentName = ComponentId;
|
|
} else {
|
|
if(HelperContext->OcManager->CurrentComponentStringId == -1) {
|
|
id = HelperContext->ComponentStringId;
|
|
} else {
|
|
id = HelperContext->OcManager->CurrentComponentStringId;
|
|
}
|
|
ComponentName = pSetupStringTableStringFromId(
|
|
HelperContext->OcManager->ComponentStringTable,
|
|
id
|
|
);
|
|
if (!ComponentName) {
|
|
rc = GetLastError();
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
rc = RegCreateKeyEx(
|
|
HelperContext->OcManager->hKeyPrivateData,
|
|
ComponentName,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_VOLATILE,
|
|
KEY_QUERY_VALUE,
|
|
NULL,
|
|
&hKey,
|
|
&Disposition
|
|
);
|
|
|
|
if(rc == NO_ERROR) {
|
|
if(IsNativeCharWidth) {
|
|
rc = RegQueryValueEx(hKey,Name,0,Type,Data,Size);
|
|
} else {
|
|
rc = RegQueryValueExA(hKey,Name,0,Type,Data,Size);
|
|
}
|
|
if(rc == ERROR_MORE_DATA) {
|
|
rc = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
exit:
|
|
return(rc);
|
|
}
|
|
|
|
UINT
|
|
#ifdef UNICODE
|
|
OcHelperGetPrivateDataW(
|
|
#else
|
|
OcHelperGetPrivateDataA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR ComponentId, OPTIONAL
|
|
IN LPCTSTR Name,
|
|
OUT PVOID Data, OPTIONAL
|
|
IN OUT PUINT Size,
|
|
OUT PUINT Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function to retrieve a named datum that was previously set via
|
|
SetPrivateData by the component or by any other component.
|
|
|
|
This routine can be called at any time.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
ComponentId - Supplies the short descriptive name of the component
|
|
(as specified in OC.INF) that set/owns the datum to be retrieved.
|
|
NULL means the current component.
|
|
|
|
Name - Supplies the name of the datum to be retrieved.
|
|
|
|
Data - If specified, receives the data. If not specified, the routine puts
|
|
the required size in Size and returns NO_ERROR.
|
|
|
|
Size - On input, supplies the size of the buffer pointed to by Data
|
|
(ignored if Data is not specified). On output, receives the size of
|
|
the data stored, or the required size if the buffer is not large enough.
|
|
|
|
Type - Upon successful completion receives the type of the datum.
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR: If Data was specified, the requested datum had been placed in
|
|
the caller's buffer. If Data was not specified, then the required size
|
|
has been placed in the UINT pointed to by Size.
|
|
|
|
ERROR_INSUFFICIENT_BUFFER: the specified buffer size is too small
|
|
to contain the datum. The required size has been placed in the UINT
|
|
pointed to by Size.
|
|
|
|
Other Win32 error codes indicate additional error cases, such as the
|
|
datum not being found, etc.
|
|
|
|
--*/
|
|
|
|
{
|
|
return(_OcHelperGetPrivateData(OcManagerContext,ComponentId,Name,Data,Size,Type,TRUE));
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
UINT
|
|
OcHelperGetPrivateDataA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR ComponentId, OPTIONAL
|
|
IN LPCSTR Name,
|
|
OUT PVOID Data, OPTIONAL
|
|
IN OUT PUINT Size,
|
|
OUT PUINT Type
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI version of OcHelperGetPrivateData().
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
LPCWSTR component;
|
|
UINT u;
|
|
|
|
if(ComponentId) {
|
|
component = pSetupAnsiToUnicode(ComponentId);
|
|
if(!component) {
|
|
u = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto c0;
|
|
}
|
|
} else {
|
|
component = NULL;
|
|
}
|
|
|
|
u = _OcHelperGetPrivateData(OcManagerContext,component,Name,Data,Size,Type,FALSE);
|
|
|
|
if(component) {
|
|
pSetupFree(component);
|
|
}
|
|
c0:
|
|
return(u);
|
|
}
|
|
#endif
|
|
|
|
|
|
UINT
|
|
OcHelperSetSetupMode(
|
|
IN PVOID OcManagerContext,
|
|
IN DWORD SetupMode
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function that can be used at any time while a component is
|
|
processing any Interface function or any of its wizard pages.
|
|
It is used to set the current setup mode. It is expected that if a
|
|
component supplies a setup mode page, it will use this routine to
|
|
inform the OC Manager of the setup mode the user chose.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
SetupMode - Supplies a numeric value that indicates the setup mode. This may be
|
|
any of the 4 standard values (minimal, laptop, custom, or typical).
|
|
It can also be any other private value that has meaning to a suite or bundle.
|
|
In that case the low 8 bits are interpreted as one of the standard values
|
|
so the mode can be meaningful to other components and the OC Manager,
|
|
who know nothing about private mode types. The component setting the mode
|
|
should attempt to set this as reasonably as possible. The upper 24 bits are
|
|
essentially private mode data.
|
|
|
|
Return Value:
|
|
|
|
The return value is the previous mode.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
UINT Mode;
|
|
|
|
Mode = p->SetupMode;
|
|
p->SetupMode = SetupMode;
|
|
|
|
return(Mode);
|
|
}
|
|
|
|
|
|
UINT
|
|
OcHelperGetSetupMode(
|
|
IN PVOID OcManagerContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function that can be used at any time while a component is processing
|
|
any Interface function or any of its wizard pages. It is used to query
|
|
the current setup mode. Note that this can be a private mode type,
|
|
in which case the low 8 bits of the mode value can be interpreted as one of
|
|
the standard 4 mode types and the upper 24 bits are private mode data.
|
|
The mode can also be unknown. See section 3.2.1 for a list of standard
|
|
mode types.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
Return Value:
|
|
|
|
The return value is the current mode.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
|
|
return(p->SetupMode);
|
|
}
|
|
|
|
|
|
BOOL
|
|
#ifdef UNICODE
|
|
OcHelperQuerySelectionStateW(
|
|
#else
|
|
OcHelperQuerySelectionStateA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR SubcomponentId,
|
|
IN UINT StateType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function that can be used at any time.
|
|
It is used determine the selection status of a particular subcomponent.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
SubcomponentId - Supplies a subidentifier meaningful to the component
|
|
being called. The OC Manager imposes no semantics on this subidentifier.
|
|
|
|
StateType - supplies a constant indicating which state is to be returned
|
|
(original or current).
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether the subcomponent is selected
|
|
for installation. If FALSE, GetLastError() will return something other than
|
|
NO_ERROR if an error occurred, such as SubcomponentId being invalid.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
OPTIONAL_COMPONENT Oc;
|
|
LONG l;
|
|
BOOL b;
|
|
|
|
l = pSetupStringTableLookUpStringEx(
|
|
p->ComponentStringTable,
|
|
(LPTSTR)SubcomponentId,
|
|
STRTAB_CASE_INSENSITIVE,
|
|
&Oc,
|
|
sizeof(OPTIONAL_COMPONENT)
|
|
);
|
|
|
|
if(l == -1) {
|
|
SetLastError(ERROR_INVALID_NAME);
|
|
return(FALSE);
|
|
}
|
|
|
|
switch(StateType) {
|
|
|
|
case OCSELSTATETYPE_ORIGINAL:
|
|
|
|
b = (Oc.OriginalSelectionState != SELSTATE_NO);
|
|
SetLastError(NO_ERROR);
|
|
break;
|
|
|
|
case OCSELSTATETYPE_CURRENT:
|
|
|
|
b = (Oc.SelectionState != SELSTATE_NO);
|
|
SetLastError(NO_ERROR);
|
|
break;
|
|
|
|
case OCSELSTATETYPE_FINAL:
|
|
|
|
b = (Oc.SelectionState != SELSTATE_NO);
|
|
SetLastError(NO_ERROR);
|
|
break;
|
|
|
|
default:
|
|
|
|
b = FALSE;
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
OcHelperQuerySelectionStateA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR SubcomponentId,
|
|
IN UINT StateType
|
|
)
|
|
{
|
|
LPCWSTR id;
|
|
DWORD d;
|
|
BOOL b;
|
|
|
|
id = pSetupAnsiToUnicode(SubcomponentId);
|
|
if(!id) {
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(FALSE);
|
|
}
|
|
|
|
b = OcHelperQuerySelectionStateW(OcManagerContext,id,StateType);
|
|
d = GetLastError();
|
|
|
|
pSetupFree(id);
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
#endif
|
|
|
|
|
|
UINT
|
|
#ifdef UNICODE
|
|
OcHelperCallPrivateFunctionW(
|
|
#else
|
|
OcHelperCallPrivateFunctionA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR ComponentId,
|
|
IN LPCTSTR SubcomponentId,
|
|
IN UINT Function,
|
|
IN UINT Param1,
|
|
IN OUT PVOID Param2,
|
|
OUT PUINT Result
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function that can be used at any time while a component is
|
|
processing any Interface function. It is used to call another component's
|
|
interface entry point to perform some private function. This function
|
|
cannot be used to call a standard interface function, nor can it be used
|
|
to call a function in the DLL of the component making the call.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
ComponentId - Supplies the short descriptive name of the component
|
|
(as specified in OC.INF) to be called. This may not be the name of
|
|
the current component.
|
|
|
|
SubcomponentId - Supplies a subidentifier meaningful to the component
|
|
being called. The OC Manager imposes no semantics on this subidentifier.
|
|
|
|
Function - Supplies a function code meaningful to the component being called.
|
|
This may not be one of the standard interface function codes.
|
|
|
|
Param1, Param2 - Supply values meaningful to the component being called.
|
|
The OC Manager imposes no semantics on these values.
|
|
|
|
Result - If the OC Manager is successful in calling the other component,
|
|
then this receives the return value from the other component's
|
|
interface routine.
|
|
|
|
Return Value:
|
|
|
|
Win32 error code indicating outcome. If NO_ERROR, then the other component
|
|
was called and the result is stored in Result. If not NO_ERROR,
|
|
then the other component was not called.
|
|
|
|
ERROR_BAD_ENVIRONMENT - the function was called when the component is not
|
|
processing an interface routine, or the caller is attempting to
|
|
call a routine in itself.
|
|
|
|
ERROR_INVALID_FUNCTION - Function is less then OC_PRIVATE_BASE.
|
|
|
|
ERROR_ACCESS_DENIED - the requested component has no interface entry point.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
BOOL b;
|
|
LONG l;
|
|
UINT i;
|
|
OPTIONAL_COMPONENT OtherOc;
|
|
LONG PreviousCurrentComponentStringId;
|
|
|
|
//
|
|
// Validate that we are processing an interface function and
|
|
// that the requested function is not a standard function,
|
|
// and that the caller wants to call a different component.
|
|
//
|
|
if(Function < OC_PRIVATE_BASE) {
|
|
return(ERROR_INVALID_FUNCTION);
|
|
}
|
|
|
|
l = pSetupStringTableLookUpStringEx(
|
|
p->ComponentStringTable,
|
|
(PTSTR)ComponentId,
|
|
STRTAB_CASE_INSENSITIVE,
|
|
&OtherOc,
|
|
sizeof(OPTIONAL_COMPONENT)
|
|
);
|
|
|
|
if(l == -1) {
|
|
return(ERROR_INVALID_FUNCTION);
|
|
}
|
|
|
|
//
|
|
// Make sure the component is top-level.
|
|
//
|
|
for(b=FALSE,i=0; !b && (i<p->TopLevelOcCount); i++) {
|
|
if(p->TopLevelOcStringIds[i] == l) {
|
|
b = TRUE;
|
|
}
|
|
}
|
|
|
|
if((l == p->CurrentComponentStringId) || (p->CurrentComponentStringId == -1) || !b) {
|
|
return(ERROR_BAD_ENVIRONMENT);
|
|
}
|
|
|
|
//
|
|
// Make sure the component has an entry point.
|
|
//
|
|
if(!OtherOc.InstallationRoutine) {
|
|
return(ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
//
|
|
// Call the other component.
|
|
//
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// If necessary, convert component and subcomponent to ansi
|
|
//
|
|
if(OtherOc.Flags & OCFLAG_ANSI) {
|
|
|
|
LPCSTR comp,subcomp;
|
|
|
|
comp = pSetupUnicodeToAnsi(ComponentId);
|
|
if(!comp) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
if(SubcomponentId) {
|
|
subcomp = pSetupUnicodeToAnsi(SubcomponentId);
|
|
if(!subcomp) {
|
|
pSetupFree(comp);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
} else {
|
|
subcomp = NULL;
|
|
}
|
|
|
|
PreviousCurrentComponentStringId = p->CurrentComponentStringId;
|
|
p->CurrentComponentStringId = l;
|
|
|
|
*Result = CallComponent(p, &OtherOc, comp, subcomp, Function, Param1, Param2);
|
|
|
|
pSetupFree(comp);
|
|
if(subcomp) {
|
|
pSetupFree(subcomp);
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
PreviousCurrentComponentStringId = p->CurrentComponentStringId;
|
|
p->CurrentComponentStringId = l;
|
|
|
|
*Result = CallComponent(p, &OtherOc, ComponentId, SubcomponentId, Function, Param1, Param2);
|
|
}
|
|
|
|
p->CurrentComponentStringId = PreviousCurrentComponentStringId;
|
|
|
|
return(NO_ERROR);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
UINT
|
|
OcHelperCallPrivateFunctionA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR ComponentId,
|
|
IN LPCSTR SubcomponentId,
|
|
IN UINT Function,
|
|
IN UINT Param1,
|
|
IN OUT PVOID Param2,
|
|
OUT PUINT Result
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI version of OcHelperCallPrivateFunction().
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
LPCWSTR comp,subcomp;
|
|
UINT u;
|
|
|
|
comp = pSetupAnsiToUnicode(ComponentId);
|
|
if(!comp) {
|
|
u = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto c0;
|
|
}
|
|
|
|
if(SubcomponentId) {
|
|
subcomp = pSetupAnsiToUnicode(SubcomponentId);
|
|
if(!subcomp) {
|
|
u = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto c1;
|
|
}
|
|
} else {
|
|
subcomp = NULL;
|
|
}
|
|
|
|
u = OcHelperCallPrivateFunctionW(
|
|
OcManagerContext,
|
|
comp,
|
|
subcomp,
|
|
Function,
|
|
Param1,
|
|
Param2,
|
|
Result
|
|
);
|
|
|
|
if(subcomp) {
|
|
pSetupFree(subcomp);
|
|
}
|
|
c1:
|
|
pSetupFree(comp);
|
|
c0:
|
|
return(u);
|
|
}
|
|
#endif
|
|
|
|
|
|
BOOL
|
|
OcHelperConfirmCancel(
|
|
IN HWND ParentWindow
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Ask the user whether he's sure he wants to cancel.
|
|
|
|
Arguments:
|
|
|
|
ParentWindow - supplies window handle of parent window for ui
|
|
|
|
Return Value:
|
|
|
|
TRUE if user wants to cancel. FALSE if not.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Message[1000];
|
|
TCHAR Caption[200];
|
|
int i;
|
|
|
|
FormatMessage(
|
|
FORMAT_MESSAGE_FROM_HMODULE,
|
|
MyModuleHandle,
|
|
MSG_QUERY_CANCEL,
|
|
0,
|
|
Message,
|
|
sizeof(Message)/sizeof(TCHAR),
|
|
NULL
|
|
);
|
|
|
|
LoadString(MyModuleHandle,IDS_SETUP,Caption,sizeof(Caption)/sizeof(TCHAR));
|
|
|
|
i = MessageBox(
|
|
ParentWindow,
|
|
Message,
|
|
Caption,
|
|
MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_SETFOREGROUND
|
|
);
|
|
|
|
return(i == IDYES);
|
|
}
|
|
|
|
|
|
HWND
|
|
OcHelperQueryWizardDialogHandle(
|
|
IN PVOID OcManagerContext
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(OcManagerContext);
|
|
|
|
return(WizardDialogHandle);
|
|
}
|
|
|
|
|
|
BOOL
|
|
OcHelperSetReboot(
|
|
IN PVOID OcManagerContext,
|
|
IN BOOL Reserved
|
|
)
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
UNREFERENCED_PARAMETER(Reserved);
|
|
|
|
p->Callbacks.SetReboot();
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
VOID
|
|
OcRememberWizardDialogHandle(
|
|
IN PVOID OcManagerContext,
|
|
IN HWND DialogHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the OC Manager client to inform the
|
|
common library of the wizard's dialog handle.
|
|
|
|
We will also turn around and notify all top-level components
|
|
of the wizard dialog handle.
|
|
|
|
Before doing so, we write the title into the window header.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - value returned from OcInitialize().
|
|
|
|
DialogHandle - supplies the dialog handle of the wizard.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
UINT i;
|
|
POC_MANAGER OcManager;
|
|
|
|
WizardDialogHandle = DialogHandle;
|
|
OcManager = OcManagerContext;
|
|
|
|
if (*OcManager->WindowTitle) {
|
|
SetWindowText(WizardDialogHandle, OcManager->WindowTitle);
|
|
}
|
|
|
|
for(i=0; i<OcManager->TopLevelOcCount; i++) {
|
|
OcInterfaceWizardCreated(OcManager,OcManager->TopLevelOcStringIds[i],DialogHandle);
|
|
}
|
|
}
|
|
|
|
|
|
HINF
|
|
OcHelperGetInfHandle(
|
|
IN UINT InfIndex,
|
|
IN PVOID OcManagerContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a handle to a well-known inf file that
|
|
has been opened by oc manager.
|
|
|
|
Arguments:
|
|
|
|
InfIndex - supplies value indicating which inf's handle is desired
|
|
|
|
OcManagerContext - value returned from OcInitialize().
|
|
|
|
Return Value:
|
|
|
|
Handle to INF, NULL if error.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER OcManager = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
|
|
return((InfIndex == INFINDEX_UNATTENDED) ? OcManager->UnattendedInf : NULL);
|
|
}
|
|
|
|
|
|
BOOL
|
|
OcHelperClearExternalError (
|
|
IN POC_MANAGER OcManager,
|
|
IN LONG ComponentId,
|
|
IN LONG SubcomponentId OPTIONAL
|
|
)
|
|
{
|
|
LONG l;
|
|
DWORD d;
|
|
HKEY hKey;
|
|
LPCTSTR pValueName;
|
|
|
|
//
|
|
// If Subcomponetid is Zero then use the ComponentId
|
|
//
|
|
if ( SubcomponentId ) {
|
|
pValueName = pSetupStringTableStringFromId(OcManager->ComponentStringTable,SubcomponentId);
|
|
} else {
|
|
pValueName = pSetupStringTableStringFromId(OcManager->ComponentStringTable,ComponentId);
|
|
}
|
|
|
|
if (!pValueName) {
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Attempt to open the key if successful delete it
|
|
//
|
|
l = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
szOcManagerErrors,
|
|
0,
|
|
KEY_QUERY_VALUE | KEY_SET_VALUE,
|
|
&hKey
|
|
);
|
|
|
|
//
|
|
// If an errror Key does not exist
|
|
//
|
|
if(l != NO_ERROR) {
|
|
d = l;
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Delete this Subcomponent Key
|
|
//
|
|
l = RegDeleteValue( hKey, pValueName);
|
|
d = l;
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
c1:
|
|
SetLastError(d);
|
|
return(d == NO_ERROR);
|
|
}
|
|
|
|
BOOL
|
|
_OcHelperReportExternalError(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR ComponentId,
|
|
IN LPCTSTR SubcomponentId, OPTIONAL
|
|
IN DWORD_PTR MessageId,
|
|
IN DWORD Flags,
|
|
IN va_list *arglist,
|
|
IN BOOL NativeCharWidth
|
|
)
|
|
{
|
|
POC_MANAGER OcManager = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
HMODULE Module;
|
|
OPTIONAL_COMPONENT Oc;
|
|
LONG l;
|
|
DWORD d;
|
|
DWORD flags;
|
|
LPTSTR MessageBuffer=NULL;
|
|
LPCTSTR KeyValue;
|
|
TCHAR fallback[20];
|
|
HKEY hKey;
|
|
DWORD Size;
|
|
TCHAR *p;
|
|
BOOL fmErr = FALSE;
|
|
|
|
if ( ComponentId == NULL ) {
|
|
//
|
|
// if Component ID is null use the Suite Inf name
|
|
//
|
|
KeyValue = OcManager->SuiteName;
|
|
|
|
//
|
|
// if the message isn't preformatted, we have to retreive an error
|
|
// from a component dll. But if a component id wasn't specified, then
|
|
// we cannot retrieve from a comopnent dll. In that case, assume
|
|
// that the message is to be retreived from the main OCM dll.
|
|
//
|
|
ZeroMemory( &Oc, sizeof(OPTIONAL_COMPONENT));
|
|
if ((Flags & ERRFLG_PREFORMATTED) == 0) {
|
|
Flags |= ERRFLG_OCM_MESSAGE;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// If SubcomponentId was Optional use the ComponentId
|
|
//
|
|
if ( SubcomponentId ) {
|
|
KeyValue = SubcomponentId;
|
|
} else {
|
|
KeyValue = ComponentId;
|
|
}
|
|
|
|
// Look up the string in the master component table.
|
|
// If it's not there, bail now.
|
|
//
|
|
l = pSetupStringTableLookUpStringEx(
|
|
OcManager->ComponentStringTable,
|
|
(PTSTR)ComponentId,
|
|
STRTAB_CASE_INSENSITIVE,
|
|
&Oc,
|
|
sizeof(OPTIONAL_COMPONENT)
|
|
);
|
|
|
|
if(l == -1) {
|
|
d = ERROR_INVALID_DATA;
|
|
goto c0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Determine flags for FormatMessage
|
|
//
|
|
flags = FORMAT_MESSAGE_ALLOCATE_BUFFER;
|
|
if(Flags & ERRFLG_SYSTEM_MESSAGE) {
|
|
flags |= FORMAT_MESSAGE_FROM_SYSTEM;
|
|
} else {
|
|
flags |= FORMAT_MESSAGE_FROM_HMODULE;
|
|
}
|
|
if(Flags & ERRFLG_IGNORE_INSERTS) {
|
|
flags |= FORMAT_MESSAGE_IGNORE_INSERTS;
|
|
}
|
|
if(Flags & ERRFLG_OCM_MESSAGE) {
|
|
flags |= FORMAT_MESSAGE_FROM_HMODULE;
|
|
|
|
}
|
|
|
|
//
|
|
// Format the message.
|
|
//
|
|
#ifdef UNICODE
|
|
if(!NativeCharWidth) {
|
|
if (Flags & ERRFLG_PREFORMATTED ) {
|
|
MessageBuffer = (LPTSTR) MessageId;
|
|
} else {
|
|
try {
|
|
d = FormatMessageA(
|
|
flags,
|
|
Flags & ERRFLG_OCM_MESSAGE?MyModuleHandle:Oc.InstallationDll, // ignored if system message
|
|
(DWORD)MessageId,
|
|
0,
|
|
(LPSTR)&MessageBuffer,
|
|
0,
|
|
arglist
|
|
);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
fmErr = TRUE;
|
|
}
|
|
if (fmErr) {
|
|
d = ERROR_INVALID_DATA;
|
|
goto c0;
|
|
}
|
|
if(d) {
|
|
//
|
|
// Need to convert resulting message from ansi to unicode
|
|
// so we can deal with it below. The LocalAlloc below overallocates
|
|
// if some of the ansi chars are double-byte chars, too bad.
|
|
//
|
|
l = lstrlen(MessageBuffer)+1;
|
|
if(p = (PVOID)LocalAlloc(LMEM_FIXED,l*sizeof(WCHAR))) {
|
|
|
|
d = MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,(LPSTR)MessageBuffer,-1,p,l);
|
|
if ( ! Flags & ERRFLG_PREFORMATTED ) {
|
|
LocalFree((HLOCAL)MessageBuffer);
|
|
}
|
|
if(d) {
|
|
MessageBuffer = p;
|
|
} else {
|
|
LocalFree((HLOCAL)p);
|
|
}
|
|
|
|
} else {
|
|
if ( ! Flags & ERRFLG_PREFORMATTED ) {
|
|
LocalFree((HLOCAL)MessageBuffer);
|
|
}
|
|
d = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
if (Flags & ERRFLG_PREFORMATTED ) {
|
|
MessageBuffer = (LPTSTR) MessageId;
|
|
d = 1;
|
|
} else {
|
|
try {
|
|
d = FormatMessage(
|
|
flags,
|
|
Flags & ERRFLG_OCM_MESSAGE?MyModuleHandle:Oc.InstallationDll, // ignored if system message
|
|
(DWORD)MessageId,
|
|
0,
|
|
(LPTSTR)&MessageBuffer,
|
|
0,
|
|
arglist
|
|
);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
fmErr = TRUE;
|
|
}
|
|
if (fmErr) {
|
|
d = ERROR_INVALID_DATA;
|
|
goto c0;
|
|
}
|
|
}
|
|
if(!d) {
|
|
//
|
|
// Put *something* in there
|
|
//
|
|
wsprintf(
|
|
fallback,
|
|
TEXT("#%s0x%x"),
|
|
(Flags & ERRFLG_SYSTEM_MESSAGE) ? TEXT("SYS") : TEXT(""),
|
|
MessageId
|
|
);
|
|
|
|
MessageBuffer = fallback;
|
|
}
|
|
}
|
|
|
|
l = RegCreateKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
szOcManagerErrors,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_QUERY_VALUE | KEY_SET_VALUE,
|
|
NULL,
|
|
&hKey,
|
|
&d
|
|
);
|
|
|
|
if(l != NO_ERROR) {
|
|
d = l;
|
|
goto c1;
|
|
}
|
|
|
|
//
|
|
// Figure out how large of a buffer we need to encompass
|
|
// the existing key and the string we're going to add to the end.
|
|
//
|
|
l = RegQueryValueEx(hKey,KeyValue,NULL,NULL,NULL,&Size);
|
|
if(l == NO_ERROR) {
|
|
if(Size == 0) {
|
|
Size = 1; // terminating nul
|
|
}
|
|
} else {
|
|
Size = sizeof(TCHAR); // terminating nul
|
|
}
|
|
|
|
Size += ((lstrlen(MessageBuffer) + 1) * sizeof(TCHAR));
|
|
|
|
//
|
|
// Allocate a buffer, read in the existing entry, and add the string
|
|
// to the end.
|
|
//
|
|
p = (PVOID)LocalAlloc(LMEM_FIXED,Size);
|
|
if(!p) {
|
|
d = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto c2;
|
|
}
|
|
|
|
l = RegQueryValueEx(hKey,KeyValue,NULL,NULL,(BYTE *)p,&Size);
|
|
if(l == NO_ERROR) {
|
|
Size /= sizeof(TCHAR);
|
|
if(Size == 0) {
|
|
Size = 1;
|
|
}
|
|
} else {
|
|
Size = 1;
|
|
}
|
|
lstrcpy(p+(Size-1),MessageBuffer);
|
|
Size += lstrlen(MessageBuffer);
|
|
p[Size++] = 0;
|
|
|
|
d = RegSetValueEx(hKey,KeyValue,0,REG_MULTI_SZ,(CONST BYTE *)p,Size*sizeof(TCHAR));
|
|
|
|
LocalFree((HLOCAL)p);
|
|
c2:
|
|
RegCloseKey(hKey);
|
|
c1:
|
|
if(MessageBuffer && MessageBuffer != fallback && MessageBuffer != (LPTSTR)MessageId ) {
|
|
LocalFree((HLOCAL)MessageBuffer);
|
|
d = 0;
|
|
}
|
|
c0:
|
|
SetLastError(d);
|
|
return(d == NO_ERROR);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pOcHelperReportExternalError(
|
|
IN POC_MANAGER OcManager,
|
|
IN LONG ComponentId,
|
|
IN LONG SubcomponentId, OPTIONAL
|
|
IN DWORD_PTR MessageId,
|
|
IN DWORD Flags,
|
|
...
|
|
)
|
|
{
|
|
BOOL b;
|
|
DWORD d;
|
|
va_list arglist;
|
|
HELPER_CONTEXT OcManagerContext;
|
|
OcManagerContext.OcManager = OcManager;
|
|
|
|
va_start(arglist,Flags);
|
|
|
|
b = _OcHelperReportExternalError(
|
|
&OcManagerContext,
|
|
ComponentId ? pSetupStringTableStringFromId(OcManager->ComponentStringTable,ComponentId):NULL,
|
|
SubcomponentId ? pSetupStringTableStringFromId(OcManager->ComponentStringTable,SubcomponentId):NULL,
|
|
MessageId,
|
|
Flags,
|
|
&arglist,
|
|
TRUE
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
va_end(arglist);
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
#ifdef UNICODE
|
|
OcHelperReportExternalErrorW(
|
|
#else
|
|
OcHelperReportExternalErrorA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR ComponentId,
|
|
IN LPCTSTR SubcomponentId, OPTIONAL
|
|
IN DWORD_PTR MessageId,
|
|
IN DWORD Flags,
|
|
...
|
|
)
|
|
{
|
|
BOOL b;
|
|
DWORD d;
|
|
|
|
va_list arglist;
|
|
|
|
va_start(arglist,Flags);
|
|
|
|
b = _OcHelperReportExternalError(
|
|
OcManagerContext,
|
|
ComponentId,
|
|
SubcomponentId,
|
|
MessageId,
|
|
Flags,
|
|
&arglist,
|
|
TRUE
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
va_end(arglist);
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
BOOL
|
|
OcHelperReportExternalErrorA(
|
|
IN PVOID OcManagerContext,
|
|
IN LPCSTR ComponentId,
|
|
IN LPCSTR SubcomponentId, OPTIONAL
|
|
IN DWORD_PTR MessageId,
|
|
IN DWORD Flags,
|
|
...
|
|
)
|
|
{
|
|
LPCWSTR componentId,subcomponentId;
|
|
DWORD d;
|
|
BOOL b;
|
|
va_list arglist;
|
|
|
|
if (ComponentId) {
|
|
componentId = pSetupAnsiToUnicode(ComponentId);
|
|
if(!componentId) {
|
|
d = ERROR_NOT_ENOUGH_MEMORY;
|
|
b = FALSE;
|
|
goto e0;
|
|
}
|
|
} else {
|
|
componentId = NULL;
|
|
}
|
|
|
|
if(SubcomponentId) {
|
|
subcomponentId = pSetupAnsiToUnicode(SubcomponentId);
|
|
if(!subcomponentId) {
|
|
d = ERROR_NOT_ENOUGH_MEMORY;
|
|
b = FALSE;
|
|
goto e1;
|
|
}
|
|
} else {
|
|
subcomponentId = NULL;
|
|
}
|
|
|
|
va_start(arglist,Flags);
|
|
|
|
b = _OcHelperReportExternalError(
|
|
OcManagerContext,
|
|
componentId,
|
|
subcomponentId,
|
|
MessageId,
|
|
Flags,
|
|
&arglist,
|
|
FALSE
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
va_end(arglist);
|
|
|
|
|
|
if(subcomponentId) {
|
|
pSetupFree(subcomponentId);
|
|
}
|
|
|
|
e1:
|
|
if (componentId) {
|
|
pSetupFree(componentId);
|
|
}
|
|
e0:
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
#endif
|
|
|
|
|
|
#if 0
|
|
BOOL
|
|
#ifdef UNICODE
|
|
OcHelperSetSelectionStateW(
|
|
#else
|
|
OcHelperSetSelectionStateA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN LPCTSTR SubcomponentId,
|
|
IN UINT WhichState,
|
|
IN UINT NewState
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function that can be used at any time.
|
|
It is used determine the selection status of a particular subcomponent.
|
|
|
|
Arguments:
|
|
|
|
OcManagerContext - supplies OC Manager context information the component gets
|
|
from the OcManagerContext field of the OCMANAGER_ROUTINES structure.
|
|
|
|
SubcomponentId - Supplies a subidentifier meaningful to the component
|
|
being called. The OC Manager imposes no semantics on this subidentifier.
|
|
|
|
StateType - supplies a constant indicating which state is to be returned
|
|
(original or current).
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether the subcomponent is selected
|
|
for installation. If FALSE, GetLastError() will return something other than
|
|
NO_ERROR if an error occurred, such as SubcomponentId being invalid.
|
|
|
|
--*/
|
|
|
|
{
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
OPTIONAL_COMPONENT Oc;
|
|
LONG l;
|
|
BOOL b;
|
|
UINT *state;
|
|
|
|
l = pSetupStringTableLookUpStringEx(
|
|
p->ComponentStringTable,
|
|
(LPTSTR)SubcomponentId,
|
|
STRTAB_CASE_INSENSITIVE,
|
|
&Oc,
|
|
sizeof(OPTIONAL_COMPONENT)
|
|
);
|
|
|
|
if(l == -1) {
|
|
SetLastError(ERROR_INVALID_NAME);
|
|
return(FALSE);
|
|
}
|
|
|
|
switch (WhichState) {
|
|
|
|
case OCSELSTATETYPE_ORIGINAL:
|
|
state = &Oc.
|
|
break;
|
|
|
|
case OCSELSTATETYPE_CURRENT:
|
|
state = &Oc.
|
|
break;
|
|
|
|
case OCSELSTATETYPE_FINAL:
|
|
state = &Oc.
|
|
break;
|
|
|
|
default:
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
if (NewState != SubcompOn && NewState != SubcompOff) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
*state = NewState;
|
|
|
|
pOcSetStatesStringWorker(l, NewState, OcPage);
|
|
|
|
return(b);
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
#ifdef UNICODE
|
|
OcLogErrorW(
|
|
#else
|
|
OcLogErrorA(
|
|
#endif
|
|
IN PVOID OcManagerContext,
|
|
IN DWORD ErrorLevel,
|
|
IN LPCTSTR Msg,
|
|
...
|
|
)
|
|
{
|
|
TCHAR sz[5000];
|
|
va_list arglist;
|
|
POC_MANAGER p = ((PHELPER_CONTEXT)OcManagerContext)->OcManager;
|
|
|
|
va_start(arglist, Msg);
|
|
_vstprintf(sz, Msg, arglist);
|
|
va_end(arglist);
|
|
|
|
return p->Callbacks.LogError(ErrorLevel, sz);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
BOOL
|
|
OcLogErrorA(
|
|
IN PVOID OcManagerContext,
|
|
IN DWORD ErrorLevel,
|
|
IN LPCSTR Msg,
|
|
...
|
|
)
|
|
{
|
|
PWSTR p;
|
|
BOOL b;
|
|
char sz[5000];
|
|
va_list arglist;
|
|
|
|
va_start(arglist, Msg);
|
|
vsprintf(sz, Msg, arglist);
|
|
va_end(arglist);
|
|
|
|
p = pSetupAnsiToUnicode(sz);
|
|
if (p) {
|
|
b = OcLogErrorW(OcManagerContext, ErrorLevel, p);
|
|
pSetupFree(p);
|
|
} else {
|
|
b = FALSE;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//
|
|
// Now that we've got all the routines defined, we can build a table
|
|
// of routines.
|
|
//
|
|
OCMANAGER_ROUTINESA HelperRoutinesA = { NULL, // Context, filled in later.
|
|
OcHelperTickGauge,
|
|
OcHelperSetProgressTextA,
|
|
OcHelperSetPrivateDataA,
|
|
OcHelperGetPrivateDataA,
|
|
OcHelperSetSetupMode,
|
|
OcHelperGetSetupMode,
|
|
OcHelperQuerySelectionStateA,
|
|
OcHelperCallPrivateFunctionA,
|
|
OcHelperConfirmCancel,
|
|
OcHelperQueryWizardDialogHandle,
|
|
OcHelperSetReboot,
|
|
OcHelperGetInfHandle,
|
|
OcHelperReportExternalErrorA,
|
|
OcHelperShowHideWizardPage
|
|
};
|
|
|
|
#ifdef UNICODE
|
|
OCMANAGER_ROUTINESW HelperRoutinesW = { NULL, // Context, filled in later.
|
|
OcHelperTickGauge,
|
|
OcHelperSetProgressTextW,
|
|
OcHelperSetPrivateDataW,
|
|
OcHelperGetPrivateDataW,
|
|
OcHelperSetSetupMode,
|
|
OcHelperGetSetupMode,
|
|
OcHelperQuerySelectionStateW,
|
|
OcHelperCallPrivateFunctionW,
|
|
OcHelperConfirmCancel,
|
|
OcHelperQueryWizardDialogHandle,
|
|
OcHelperSetReboot,
|
|
OcHelperGetInfHandle,
|
|
OcHelperReportExternalErrorW,
|
|
OcHelperShowHideWizardPage
|
|
};
|
|
#endif
|
|
|
|
EXTRA_ROUTINESA ExtraRoutinesA = { sizeof(EXTRA_ROUTINESA),
|
|
OcLogErrorA
|
|
};
|
|
|
|
#ifdef UNICODE
|
|
EXTRA_ROUTINESW ExtraRoutinesW = { sizeof(EXTRA_ROUTINESW),
|
|
OcLogErrorW
|
|
};
|
|
#endif
|