Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/sdktools/wintueor/missy/a_sysacc.c

3356 lines
79 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
A_SysAcc.c
Abstract:
This module contains the code related to the System Access
security area and it's corresponding items.
Author:
Jim Kelly (JimK) 22-Mar-1995
Revision History:
--*/
#include "Missyp.h"
//
// Number of items in this area and their index in various item-arrays
//
#define MISSYP_SYSACC_ITEM_COUNT (5)
#define MISSYP_ITEM_LOGON_CACHE (0)
#define MISSYP_ITEM_UNLOCK (1)
#define MISSYP_ITEM_SHUTDOWN (2)
#define MISSYP_ITEM_LAST_USERNAME (3)
#define MISSYP_ITEM_LEGAL_NOTICE (4)
//
// Legal notice length limitations
//
#define MISSYP_MAX_CAPTION_LENGTH 200
#define MISSYP_MAX_BODY_LENGTH 2048
///////////////////////////////////////////////////////////////////////
// //
// Module-wide variables //
// //
///////////////////////////////////////////////////////////////////////
//
// The index of this area within the array of area descriptors
// in the Smedly control structure.
//
ULONG
MissypSysAccIndex ;
PSECMGR_AREA_DESCRIPTOR
MissypSysAccArea;
WCHAR
MissypSysAccAreaName[SECMGR_MAX_AREA_NAME_LENGTH],
MissypSysAccAreaDesc[SECMGR_MAX_AREA_DESC_LENGTH];
//
// Array of items within this area
//
SECMGR_ITEM_DESCRIPTOR
MissypSysAccItems[MISSYP_SYSACC_ITEM_COUNT];
//
// The following variables represent the current settings in the
// SYSTEM ACCESS dialog. The values for each are:
//
// CurrentCacheSize - ULONG, 0 to MISSYP_MAX_LOGON_CACHE_COUNT
//
// CurrentUnlock -
// MISSYP_ID_RADIO_UNLOCK_ADMIN
//
// CurrentShutdown -
// MISSYP_ID_RADIO_SHUTDOWN_ANYONE
// MISSYP_ID_RADIO_SHUTDOWN_LOGGED_ON
// MISSYP_ID_RADIO_SHUTDOWN_OPERS
// MISSYP_ID_RADIO_SHUTDOWN_ADMIN
//
// CurrentLastName -
// MISSYP_ID_RADIO_LASTNAME_DISPLAY
// MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY
//
// CurrentLegalNotice -
// MISSYP_ID_RADIO_LEGAL_NOTICE_NONE
// MISSYP_ID_RADIO_LEGAL_NOTICE
//
// LegalNoticeCaption -
// Only valid when CurrentLegalNotice has the value
// MISSYP_ID_RADIO_LEGAL_NOTICE. In that case,
// points to a string containing the legal notice title
// bar text.
//
// LegalNoticeBody -
// Only valid when CurrentLegalNotice has the value
// MISSYP_ID_RADIO_LEGAL_NOTICE. In that case,
// points to a string containing the legal notice body
// text.
//
ULONG
MissypCurrentCacheSize,
MissypCurrentUnlock,
MissypCurrentShutdown,
MissypCurrentLastName,
MissypCurrentLegalNotice;
//
// Because setting some values takes so long, it is worth
// remembering the initial values so we can determine whether
// or not they have changed.
//
ULONG
MissypOriginalCacheSize,
MissypOriginalUnlock,
MissypOriginalShutdown,
MissypOriginalLastName,
MissypOriginalLegalNotice;
BOOLEAN
MissypOriginalLegalNoticeChanged;
WCHAR
MissypLegalNoticeCaptionBuffer[MISSYP_MAX_CAPTION_LENGTH],
MissypLegalNoticeBodyBuffer[MISSYP_MAX_BODY_LENGTH];
UNICODE_STRING
MissypCurrentLegalNoticeCaption =
{0, MISSYP_MAX_CAPTION_LENGTH, MissypLegalNoticeCaptionBuffer },
MissypCurrentLegalNoticeBody =
{0, MISSYP_MAX_BODY_LENGTH, MissypLegalNoticeBodyBuffer };
///////////////////////////////////////////////////////////////////////
// //
// Local Function Prototypes //
// //
///////////////////////////////////////////////////////////////////////
LONG
MissypDlgProcSysAccess(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
);
BOOLEAN
MissypDisplayUnlock(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
BOOLEAN
MissypDisplayShutdown(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
BOOLEAN
MissypDisplayLastName(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
BOOLEAN
MissypDisplayLogonCache(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
BOOLEAN
MissypDisplayLegalNotice(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
BOOLEAN
MissypSysAccInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
);
VOID
MissypGreyLegalNotice(
HWND hwnd,
BOOLEAN Grey
);
BOOLEAN
MissypSysAccApplyCurrentSettings( HWND hwnd );
VOID
MissypWarnOfAutologon( HWND hwnd );
LONG
MissypDlgProcWarnOfAutologon(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
);
BOOLEAN
MissypLastNameInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
);
BOOLEAN
MissypLogonCacheInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
);
BOOLEAN
MissypUnlockInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
);
BOOLEAN
MissypShutdownInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
);
BOOLEAN
MissypLegalNoticeInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
);
///////////////////////////////////////////////////////////////////////
// //
// Externally callable functions //
// //
///////////////////////////////////////////////////////////////////////
BOOL
MissypSysAccInitialize(
IN ULONG AreaIndex
)
/*++
Routine Description:
This function is called to initialize the System Access area
and corresponding items. This includes adding the System Access
area/item information to the smedly control structure (MissypControl).
The security manager control information (in the global variable
MissypSecMgrControl) must be available before this routine is called.
Arguments
AreaIndex - The index of this area in the array of areas kept in the
Missy control structure.
Return Values:
TRUE - The call completed successfully.
FALSE - Something went wrong. GetLastError() contains
details on the exact cause of the error. Possible
values include:
ERROR_NOT_ENOUGH_MEMORY
--*/
{
ULONG
ItemIndex;
MissypSysAccIndex = AreaIndex;
LoadString( MissyphInstance,
MISSYP_STRING_AREA_SYSTEM_ACCESS_NAME,
&MissypSysAccAreaName[0],
SECMGR_MAX_AREA_NAME_LENGTH
);
LoadString( MissyphInstance,
MISSYP_STRING_AREA_SYSTEM_ACCESS_DESC,
&MissypSysAccAreaDesc[0],
SECMGR_MAX_AREA_DESC_LENGTH
);
//
// Initialize our area
//
//
MissypSysAccArea = &MissypControl.Areas[AreaIndex];
MissypSysAccArea->Revision.Major = SECMGR_REVISION_MAJOR_1;
MissypSysAccArea->Revision.Minor = SECMGR_REVISION_MINOR_0;
MissypSysAccArea->Flags = SECMGR_AREA_FLAG_AREA_VIEW;
MissypSysAccArea->SmedlyContext = NULL; // Missy doesn't use this yet
MissypSysAccArea->SmedlyControl = (PVOID)(&MissypControl);
MissypSysAccArea->AreaIndex = AreaIndex;
MissypSysAccArea->Name = MissypSysAccAreaName;
MissypSysAccArea->Description = MissypSysAccAreaDesc;
MissypSysAccArea->ItemCount = MISSYP_SYSACC_ITEM_COUNT;
MissypSysAccArea->Items = &MissypSysAccItems[0];
//
// Initialize each item
// NOTE: We should add Interactive, network, Service, and Batch logon types
// to these items.
//
if (!MissypLogonCacheInitialize( MissypSysAccArea,
&MissypSysAccItems[MISSYP_ITEM_LOGON_CACHE],
MISSYP_ITEM_LOGON_CACHE )) {
return(FALSE);
}
if (!MissypUnlockInitialize( MissypSysAccArea,
&MissypSysAccItems[MISSYP_ITEM_UNLOCK],
MISSYP_ITEM_UNLOCK )) {
return(FALSE);
}
if (!MissypShutdownInitialize( MissypSysAccArea,
&MissypSysAccItems[MISSYP_ITEM_SHUTDOWN],
MISSYP_ITEM_SHUTDOWN )) {
return(FALSE);
}
if (!MissypLastNameInitialize( MissypSysAccArea,
&MissypSysAccItems[MISSYP_ITEM_LAST_USERNAME],
MISSYP_ITEM_LAST_USERNAME )) {
return(FALSE);
}
if (!MissypLegalNoticeInitialize( MissypSysAccArea,
&MissypSysAccItems[MISSYP_ITEM_LEGAL_NOTICE],
MISSYP_ITEM_LEGAL_NOTICE )) {
return(FALSE);
}
}
BOOL
MissypSysAccInvokeArea(
IN HWND hwnd,
IN BOOL AllowChanges,
IN BOOL Interactive,
IN PSECMGR_AREA_DESCRIPTOR Area
)
/*++
Routine Description:
This function is called to activate this area's full-screen dialog
Arguments
hwnd - A handle to a Security Manager window which is the parent
of the dialog the smedly is expected to display.
AllowChanges - If TRUE, then the user may make changes to values
displayed in the area. Otherwise, the area should be presented
in a view-only mode.
Interactive - Indicates whether or not the area should be displayed or
not. If TRUE, then UI showing the area information to the user
should be presented. If FALSE, then the area should initialize its
item values, but return immediately without actually displaying any
UI.
Area - Pointer to this Area's descriptor.
Return Values:
TRUE - The routine completed successfully. Item values may or may not
have changed.
FALSE - The routine failed to complete successfully. GetLastError()
contains further information about the cause of failure.
--*/
{
if (Interactive) {
DialogBoxParam(MissyphInstance,
MAKEINTRESOURCE(MISSYP_ID_DLG_AREA_SYSACC),
hwnd,
(DLGPROC)MissypDlgProcSysAccess,
(LONG)AllowChanges
);
} else {
MissypSysAccInitDialog( hwnd, AllowChanges, FALSE ); // Non-interactive
}
return(TRUE);
}
BOOL
MissypSysAccInvokeItem(
IN HWND hwnd,
IN BOOL AllowChanges,
IN PSECMGR_AREA_DESCRIPTOR Area,
IN PSECMGR_ITEM_DESCRIPTOR Item
)
/*++
Routine Description:
This function is called when the dialog view of
a particular item is requested. The smedly is responsible
for providing the dialogs of this view to the user.
This routine will only be invoked for items for which
SECMGR_ITEM_FLAG_ITEM_VIEW is specified in the Flags field
of the SECMGR_ITEM_DESCRIPTOR.
Arguments
hwnd - A handle to a Security Manager window which is the parent
of the dialog the smedly is expected to display.
AllowChanges - If TRUE, then the user may make changes to values
displayed for the item. Otherwise, the item should be presented
in a view-only mode.
Area - Pointer to this area.
Item - Pointer to the item of this area to be displayed.
Return Values:
TRUE - The routine completed successfully. The current item value
may or may not have changed.
FALSE - The routine failed to complete successfully. GetLastError()
contains further information about the cause of failure.
--*/
{
BOOL
Result;
if (!(Item->Flags & SECMGR_ITEM_FLAG_ITEM_VIEW)) {
return(TRUE);
}
switch (Item->ItemIndex) {
case MISSYP_ITEM_LOGON_CACHE:
Result = MissypInvokeLogonCache( hwnd, AllowChanges, Area, Item );
break;
case MISSYP_ITEM_UNLOCK:
Result = MissypInvokeUnlock( hwnd, AllowChanges, Area, Item );
break;
case MISSYP_ITEM_SHUTDOWN:
Result = MissypInvokeShutdown( hwnd, AllowChanges, Area, Item );
break;
case MISSYP_ITEM_LEGAL_NOTICE:
Result = MissypInvokeLegalNotice( hwnd, AllowChanges, Area, Item );
break;
case MISSYP_ITEM_LAST_USERNAME:
Result = MissypInvokeLastName( hwnd, AllowChanges, Area, Item );
break;
default:
Result = FALSE;
break;
} //end_switch
return(Result);
}
BOOL
MissypSysAccNewSecurityLevel( VOID )
/*++
Routine Description:
This function is called when a new system security level has
been selected. This may cause a Smedly to go out and re-evaluate
its recommended values for the specified area.
Arguments
Area - Pointer to this Area.
Return Values:
TRUE - The routine completed successfully. Item values and recommendations
may or may not have changed.
FALSE - The routine failed to complete successfully. GetLastError()
contains further information about the cause of failure.
--*/
{
//
// Have each item update its recommended value
//
MissypUpdateLogonCacheRecommendation( NULL );
MissypUpdateUnlockRecommendation( );
MissypUpdateShutdownRecommendation();
MissypUpdateLastNameRecommendation();
MissypUpdateLegalNoticeRecommendation( NULL );
return(TRUE);
}
VOID
MissypSysAccReportFileChange(
IN BOOL ReportFileActive,
IN DWORD Pass
)
/*++
Routine Description:
This function is called to notify us that a new report
file has been activated. This gives us an opportunity
to put some area-specific information into the report file.
Arguments
ReportFileActive - If TRUE indicates that a new report file has been opened.
If FALSE, indicates that a report file has been closed, and another was
not opened.
Return Values:
None.
--*/
{
return;
}
BOOL
MissypSysAccGenerateProfile( VOID )
/*++
Routine Description:
This function is called to request a security profile of this area.
Arguments
None
Return Values:
TRUE - The routine completed successfully.
FALSE - The routine failed to complete successfully. GetLastError()
contains further information about the cause of failure.
--*/
{
BOOL
Result;
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
Result = FALSE;
return(Result);
}
BOOL
MissypSysAccApplyProfile( VOID )
/*++
Routine Description:
This function is called to request a profile of this area be applied
to the current system.
Arguments
None.
Return Values:
TRUE - The routine completed successfully.
FALSE - The routine failed to complete successfully. GetLastError()
contains further information about the cause of failure.
--*/
{
BOOL
Result;
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
Result = FALSE;
return(Result);
}
///////////////////////////////////////////////////////////////////////
// //
// Locally callable functions //
// //
///////////////////////////////////////////////////////////////////////
LONG
MissypDlgProcSysAccess(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the System Access dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
WORD
NotificationCode,
ControlId;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypSysAccInitDialog( hwnd, ChangesAllowed, TRUE ) ) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Put up our "recommended" symbols
//
MissypDisplayXGraphic( hwnd, MISSYP_ID_SYMBOL_STRONGER, TRUE );
MissypDisplayXGraphic( hwnd, MISSYP_ID_SYMBOL_WEAKER, FALSE );
MissypDisplayCheckGraphic( hwnd, MISSYP_ID_SYMBOL_RECOMMEND );
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
//
// Now check a few things that this utility does not provide
// a UI to change. Put up a warning if an unusual setting
// is found...
//
MissypWarnOfAutologon( hwnd );
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
//
// wParam WIN32- HIWORD = notification code,
// LOWORD = ID of control
// WIN16- ID of control
//
// lParam WIN32- hWnd of Control
// WIN16- HIWORD = notification code
// LOWORD = hWnd of control
//
//NotificationCode = GET_NOTIFY_MSG(wParam, lParam);
//ControlId = GET_CONTROL_ID(wParam);
NotificationCode = HIWORD(wParam);
ControlId = LOWORD(wParam);
switch(ControlId) {
case MISSYP_ID_BUTTON_LOGCAC_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_LOGON_CACHE );
return(TRUE);
case MISSYP_ID_BUTTON_UNLOCK_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_UNLOCK_WORKSTATION );
return(TRUE);
case MISSYP_ID_BUTTON_SHUTDOWN_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_SHUTDOWN_SYSTEM );
return(TRUE);
case MISSYP_ID_BUTTON_LASTNAME_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_LAST_USERNAME );
return(TRUE);
case MISSYP_ID_BUTTON_LEGAL_NOTICE_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_LEGAL_NOTICE );
return(TRUE);
case MISSYP_ID_RADIO_UNLOCK_ANYONE:
MissypCurrentUnlock = SecMgrAnyone;
return(TRUE);
case MISSYP_ID_RADIO_UNLOCK_ADMIN:
MissypCurrentUnlock = SecMgrAdminsOnly;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_ANYONE:
MissypCurrentShutdown = SecMgrAnyone;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_LOGGED_ON:
MissypCurrentShutdown = SecMgrAnyoneLoggedOn;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_OPERS:
MissypCurrentShutdown = SecMgrOpersAndAdmins;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_ADMIN:
MissypCurrentShutdown = SecMgrAdminsOnly;
return(TRUE);
case MISSYP_ID_RADIO_LASTNAME_DISPLAY:
case MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY:
MissypCurrentLastName = LOWORD(wParam);
return(TRUE);
case MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION:
case MISSYP_ID_EDIT_LEGAL_NOTICE_BODY:
//
// Just note that the notice has changed
//
if (NotificationCode == EN_UPDATE) {
MissypOriginalLegalNoticeChanged = TRUE;
}
return(TRUE);
case MISSYP_ID_RADIO_LEGAL_NOTICE_NONE:
MissypGreyLegalNotice( hwnd, TRUE );
MissypCurrentLegalNotice = ControlId;
if (MissypOriginalLegalNotice != MissypCurrentLegalNotice) {
MissypOriginalLegalNoticeChanged = TRUE;
} else {
;
//MissypOriginalLegalNoticeChanged = FALSE;
}
return(TRUE);
case MISSYP_ID_RADIO_LEGAL_NOTICE:
MissypGreyLegalNotice( hwnd, FALSE );
MissypCurrentLegalNotice = ControlId;
//
// If the original setting was "LEGAL NOTICE", we can't
// say that the original notice hasn't changed if we
// re-select this button. This is because the text of
// the message might have changed.
//
if (MissypOriginalLegalNotice != MissypCurrentLegalNotice) {
MissypOriginalLegalNoticeChanged = TRUE;
}
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
//
// Get the legal notice strings, if necessary
//
if (MissypOriginalLegalNoticeChanged) {
if (MissypCurrentLegalNotice == MISSYP_ID_RADIO_LEGAL_NOTICE ) {
MissypCurrentLegalNoticeCaption.Length =
GetDlgItemText(hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION,
MissypCurrentLegalNoticeCaption.Buffer,
MissypCurrentLegalNoticeCaption.MaximumLength
);
MissypCurrentLegalNoticeBody.Length =
GetDlgItemText(hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_BODY,
MissypCurrentLegalNoticeBody.Buffer,
MissypCurrentLegalNoticeBody.MaximumLength
);
}
}
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
case WM_VSCROLL:
Index = GetWindowLong((HWND)lParam, GWL_ID);
switch (Index) {
case MISSYP_ID_SPIN_LOGCAC_APPLY:
Changed = FALSE;
if (LOWORD(wParam) == SB_LINEUP) {
if (MissypCurrentCacheSize < MISSYP_MAX_LOGON_CACHE_COUNT) {
MissypCurrentCacheSize++;
Changed = TRUE;
}
} else if (LOWORD(wParam) == SB_LINEDOWN) {
if (MissypCurrentCacheSize > 0) {
MissypCurrentCacheSize--;
Changed = TRUE;
}
}
if (Changed) {
SetDlgItemInt( hwnd,
MISSYP_ID_TEXT_LOGCAC_APPLY,
MissypCurrentCacheSize,
FALSE // Not signed value
);
}
return(TRUE);
default:
break;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypSysAccInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves current values and recommended values
for the items of this area. These values are set in both the
item control structures and in module-wide current-setting
variables.
If we are in Interactive Mode his function also initializes the
System Access dialog box with the current values and recommended
values. This may be used for both Read-only and Read-Write
operations.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// There are two ways to go about retrieving current settings.
// One way is to retrieve them at Utility init time and just
// keep their value around. The other is to get the values each
// time our dialog is activated. We use the later approach here
// to allow for changes that might be made outside the Security
// Manager (perhaps directly via a registry editor or via the User
// Manager).
//
if (MissypDisplayUnlock( hwnd, ChangesAllowed, Interactive )) {
if (MissypDisplayShutdown( hwnd, ChangesAllowed, Interactive )) {
if (MissypDisplayLastName( hwnd, ChangesAllowed, Interactive)) {
if (MissypDisplayLegalNotice( hwnd, ChangesAllowed, Interactive )) {
if (MissypDisplayLogonCache( hwnd, ChangesAllowed, Interactive )) {
return(TRUE);
}
}
}
}
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
BOOLEAN
MissypDisplayLogonCache(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves the current logon cache settings and
establishes the correct recommendation in the SYSTEM ACCESS dialog.
The current setting is placed in MissypCurrentCacheSize.
Arguments
hwnd - handle to dialog
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - Completed successfully.
FALSE - Did not complete successfully.
A popup has been displayed.
The dialog should be terminated.
--*/
{
BOOLEAN
Result;
ULONG
Recommendation;
HWND
Control;
Result = MissypGetLogonCacheCount( hwnd,
&MissypCurrentCacheSize,
&Recommendation);
if (!Result) {
//
// Put up a popup here.
//
return(FALSE);
}
if (Interactive) {
//
// Setting is stronger than Recommendation if fewer entries in the cache.
//
if (Recommendation == MissypCurrentCacheSize) {
MissypDisplayCheckGraphic( hwnd, MISSYP_ID_RECOMMEND_LOGON_CACHE );
} else if ( Recommendation > MissypCurrentCacheSize) {
MissypDisplayXGraphic( hwnd, MISSYP_ID_RECOMMEND_LOGON_CACHE, TRUE ); // Green X
} else {
MissypDisplayXGraphic( hwnd, MISSYP_ID_RECOMMEND_LOGON_CACHE, FALSE ); // Red X
}
SetDlgItemInt( hwnd,
MISSYP_ID_TEXT_LOGCAC_RECOMMEND,
Recommendation,
FALSE // Not signed value
);
SetDlgItemInt( hwnd,
MISSYP_ID_TEXT_LOGCAC_CURRENT,
MissypCurrentCacheSize,
FALSE // Not signed value
);
SetDlgItemInt( hwnd,
MISSYP_ID_TEXT_LOGCAC_APPLY,
MissypCurrentCacheSize,
FALSE // Not signed value
);
//
// If changes aren't allowed, then hide the modification controls
//
if (!ChangesAllowed) {
Control = GetDlgItem(hwnd, MISSYP_ID_TEXT_LOGCAC_APPLY);
ShowWindow(Control, SW_HIDE);
Control = GetDlgItem(hwnd, MISSYP_ID_TEXT_LOGCAC_APPLY_LINE);
ShowWindow(Control, SW_HIDE);
Control = GetDlgItem(hwnd, MISSYP_ID_SPIN_LOGCAC_APPLY);
ShowWindow(Control, SW_HIDE);
}
} // end_if (Interactive)
MissypOriginalCacheSize = MissypCurrentCacheSize;
return(TRUE);
}
BOOLEAN
MissypDisplayUnlock(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves the current unlock setting and establishes
the correct recommendation in the SYSTEM ACCESS dialog.
The current setting is placed in MissypCurrentUnlock.
Arguments
hwnd - handle to dialog
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - Completed successfully.
FALSE - Did not complete successfully.
A popup has been displayed.
The dialog should be terminated.
--*/
{
SECMGR_WHO
Who;
HWND
Control;
ULONG
RecommendedId,
CurrentlySetId;
SECMGR_WHO
Recommendation;
//
// This not only gets the value, but sets it and the recommended
// setting in the Unlock Item control block
//
MissypGetUnlockSetting( hwnd, &Who );
//
// Get the right radio button setting
//
if (Who == SecMgrAnyone) {
MissypCurrentUnlock = MISSYP_ID_RADIO_UNLOCK_ANYONE;
CurrentlySetId = MISSYP_ID_RECOMMEND_UNLOCK_ANYONE;
} else {
ASSERT(Who == SecMgrAdminsOnly);
MissypCurrentUnlock = MISSYP_ID_RADIO_UNLOCK_ADMIN;
CurrentlySetId = MISSYP_ID_RECOMMEND_UNLOCK_ADMIN;
}
//
// set the dialog controls appropriately
//
if (Interactive) {
//
// Clear all recommendation boxes and then set the correct one
//
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_UNLOCK_ANYONE );
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_UNLOCK_ADMIN );
Recommendation = MissypGetUnlockRecommendation( SECMGR_LEVEL_CURRENT );
switch (Recommendation) {
case SecMgrAnyone:
RecommendedId = MISSYP_ID_RECOMMEND_UNLOCK_ANYONE;
break;
case SecMgrAdminsOnly:
RecommendedId = MISSYP_ID_RECOMMEND_UNLOCK_ADMIN;
break;
} //end_switch
MissypDisplayCheckGraphic( hwnd, RecommendedId );
//
// If this isn't what is set, then put an X on the currently set value
//
if (CurrentlySetId != RecommendedId) {
if (RecommendedId > CurrentlySetId) {
MissypDisplayXGraphic( hwnd, CurrentlySetId, FALSE ); //Weaker
} else {
MissypDisplayXGraphic( hwnd, CurrentlySetId, TRUE ); //Stronger
}
}
//
// Set the right radio button
//
CheckRadioButton( hwnd,
MISSYP_ID_RADIO_UNLOCK_ANYONE,
MISSYP_ID_RADIO_UNLOCK_ADMIN,
MissypCurrentUnlock);
//
// If we don't match the recommended setting, then put an
// X by the current setting.
//
//
// If changes aren't allowed, then grey the radio buttons
//
if (!ChangesAllowed) {
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_UNLOCK_ANYONE);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_UNLOCK_ADMIN);
EnableWindow( Control, FALSE );
}
}
//
// Save the original value
//
MissypOriginalUnlock = MissypCurrentUnlock;
return(TRUE);
}
BOOLEAN
MissypDisplayShutdown(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves the current shutdown setting and establishes
the correct recommendation in the SYSTEM ACCESS dialog.
The current setting is placed in MissypCurrentShutdown.
Arguments
hwnd - handle to dialog
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - Completed successfully.
FALSE - Did not complete successfully.
A popup has been displayed.
The dialog should be terminated.
--*/
{
BOOLEAN
Result;
SECMGR_WHO
Who,
Recommendation;
HWND
Control;
INT
RecommendedId,
CurrentlySetId;
Result = MissypGetShutdownSetting( hwnd, &Who, Interactive );
if (!Result) {
//
// Display popup
//
//bugbug PopUp
return(FALSE);
}
//
// Select the appropriate button
//
switch (Who) {
case SecMgrAnyone:
MissypCurrentShutdown = MISSYP_ID_RADIO_SHUTDOWN_ANYONE;
CurrentlySetId = MISSYP_ID_RECOMMEND_SHUTDOWN_ANYONE;
break;
case SecMgrAnyoneLoggedOn:
MissypCurrentShutdown = MISSYP_ID_RADIO_SHUTDOWN_LOGGED_ON;
CurrentlySetId = MISSYP_ID_RECOMMEND_SHUTDOWN_LOGGED_ON;
break;
case SecMgrOpersAndAdmins:
MissypCurrentShutdown = MISSYP_ID_RADIO_SHUTDOWN_OPERS;
CurrentlySetId = MISSYP_ID_RECOMMEND_SHUTDOWN_OPERS;
break;
case SecMgrAdminsOnly:
MissypCurrentShutdown = MISSYP_ID_RADIO_SHUTDOWN_ADMIN;
CurrentlySetId = MISSYP_ID_RECOMMEND_SHUTDOWN_ADMIN;
break;
}
if (Interactive) {
//
// Clear all recommendation boxes and then set the correct one
//
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_SHUTDOWN_ANYONE );
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_SHUTDOWN_LOGGED_ON );
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_SHUTDOWN_OPERS );
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_SHUTDOWN_ADMIN );
//
// Set the recommendation
//
Recommendation = MissypGetShutdownRecommendation( SECMGR_LEVEL_CURRENT );
switch (Recommendation) {
case SecMgrAnyone:
RecommendedId = MISSYP_ID_RECOMMEND_SHUTDOWN_ANYONE;
break;
case SecMgrAnyoneLoggedOn:
RecommendedId = MISSYP_ID_RECOMMEND_SHUTDOWN_LOGGED_ON;
break;
case SecMgrOpersAndAdmins:
RecommendedId = MISSYP_ID_RECOMMEND_SHUTDOWN_OPERS;
break;
case SecMgrAdminsOnly:
RecommendedId = MISSYP_ID_RECOMMEND_SHUTDOWN_ADMIN;
break;
} //end_switch
MissypDisplayCheckGraphic( hwnd, RecommendedId );
//
// If this isn't what is set, then put an X on the currently set value
//
if (CurrentlySetId != RecommendedId) {
if (RecommendedId > CurrentlySetId) {
MissypDisplayXGraphic( hwnd, CurrentlySetId, FALSE ); // Weaker
} else {
MissypDisplayXGraphic( hwnd, CurrentlySetId, TRUE ); // Stronger
}
}
//
// Set the radio buttons accordingly
//
CheckRadioButton( hwnd,
MISSYP_ID_RADIO_SHUTDOWN_ANYONE,
MISSYP_ID_RADIO_SHUTDOWN_ADMIN,
MissypCurrentShutdown);
//
// If changes aren't allowed, then grey the radio buttons
//
if (!ChangesAllowed) {
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_SHUTDOWN_ANYONE);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_SHUTDOWN_LOGGED_ON);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_SHUTDOWN_OPERS);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_SHUTDOWN_ADMIN);
EnableWindow( Control, FALSE );
}
}
MissypOriginalShutdown = MissypCurrentShutdown;
return(TRUE);
}
BOOLEAN
MissypDisplayLastName(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves the current LastName setting and establishes
the correct recommendation in the SYSTEM ACCESS dialog.
The current setting is placed in MissypCurrentLastName.
Arguments
hwnd - handle to dialog
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - Completed successfully.
FALSE - Did not complete successfully.
A popup has been displayed.
The dialog should be terminated.
--*/
{
BOOL
Display;
HWND
Control;
INT
RecommendedId,
CurrentlySetId;
MissypGetLastNameSetting( hwnd, &Display );
//
// Set the radio buttons accordingly
//
if (Display) {
MissypCurrentLastName = MISSYP_ID_RADIO_LASTNAME_DISPLAY;
CurrentlySetId = MISSYP_ID_RECOMMEND_LASTNAME_DISPLAY;
} else {
MissypCurrentLastName = MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY;
CurrentlySetId = MISSYP_ID_RECOMMEND_LASTNAME_DONT_DISPLAY;
}
if (Interactive) {
//
// Clear all recommendation boxes and then set the correct one
//
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_LASTNAME_DISPLAY);
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_LASTNAME_DONT_DISPLAY );
if (MissypGetLastNameRecommendation( SECMGR_LEVEL_CURRENT )) {
RecommendedId = MISSYP_ID_RECOMMEND_LASTNAME_DISPLAY;
} else {
RecommendedId = MISSYP_ID_RECOMMEND_LASTNAME_DONT_DISPLAY;
}
MissypDisplayCheckGraphic( hwnd, RecommendedId );
//
// If this isn't what is set, then put an X on the currently set value
//
if (CurrentlySetId != RecommendedId) {
MissypDisplayXGraphic( hwnd, CurrentlySetId, !Display );
}
CheckRadioButton( hwnd,
MISSYP_ID_RADIO_LASTNAME_DISPLAY,
MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY,
MissypCurrentLastName);
//
// If changes aren't allowed, then grey the radio buttons
//
if (!ChangesAllowed) {
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_LASTNAME_DISPLAY);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY);
EnableWindow( Control, FALSE );
}
}
MissypOriginalLastName = MissypCurrentLastName;
return(TRUE);
}
BOOLEAN
MissypDisplayLegalNotice(
IN HWND hwnd,
IN BOOL ChangesAllowed,
IN BOOL Interactive
)
/*++
Routine Description:
This function retrieves the current legal notice setting and
establishes the correct recommendation in the SYSTEM ACCESS dialog.
It also greys the caption and body fields if no legal notice is
in effect.
The current setting is placed in MissypCurrentLegalNotice, and
MissypLegalNoticeCaption and MissypLegalNoticeBody will be set
to either NULL, or to point to appropriate strings.
Arguments
hwnd - handle to dialog
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
InteractiveMode - TRUE: Interactive Mode
FALSE: Non-Interactive Mode
Return Values:
TRUE - Completed successfully.
FALSE - Did not complete successfully.
A popup has been displayed.
The dialog should be terminated.
--*/
{
HWND
Control;
INT
RecommendedId,
CurrentlySetId;
SECMGR_WHO
Recommendation;
if (!MissypGetLegalNotice( hwnd,
&MissypCurrentLegalNoticeCaption,
&MissypCurrentLegalNoticeBody) ) {
// bugbug - put up a popup
return(FALSE);
}
if ( (MissypCurrentLegalNoticeCaption.Length != 0) ||
(MissypCurrentLegalNoticeBody.Length != 0) ) {
MissypCurrentLegalNotice = MISSYP_ID_RADIO_LEGAL_NOTICE;
CurrentlySetId = MISSYP_ID_RECOMMEND_LEGAL_NOTICE;
} else {
MissypCurrentLegalNotice = MISSYP_ID_RADIO_LEGAL_NOTICE_NONE;
CurrentlySetId = MISSYP_ID_RECOMMEND_LEGAL_NOTICE_NONE;
}
if (Interactive) {
//
// Clear all recommendation boxes and then set the correct one
//
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_LEGAL_NOTICE);
MissypEraseGraphic( hwnd, MISSYP_ID_RECOMMEND_LEGAL_NOTICE_NONE );
if (MissypGetLegalNoticeRecommendation( SECMGR_LEVEL_CURRENT )) {
RecommendedId = MISSYP_ID_RECOMMEND_LEGAL_NOTICE;
} else {
RecommendedId = MISSYP_ID_RECOMMEND_LEGAL_NOTICE_NONE;
}
MissypDisplayCheckGraphic( hwnd, RecommendedId );
//
// If this isn't what is set, then put an X on the currently set value
//
if (CurrentlySetId != RecommendedId) {
MissypDisplayXGraphic( hwnd, CurrentlySetId, FALSE );
}
//
// Set the radio buttons accordingly
//
CheckRadioButton( hwnd,
MISSYP_ID_RADIO_LEGAL_NOTICE_NONE,
MISSYP_ID_RADIO_LEGAL_NOTICE,
MissypCurrentLegalNotice);
//
// If we have a legal notice, then display it.
// Otherwise, grey the legal notice edit boxes.
//
if (MissypCurrentLegalNotice == MISSYP_ID_RADIO_LEGAL_NOTICE) {
if (MissypCurrentLegalNoticeCaption.Length != 0) {
SetDlgItemText( hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION,
MissypCurrentLegalNoticeCaption.Buffer);
}
if (MissypCurrentLegalNoticeBody.Length != 0) {
SetDlgItemText( hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_BODY,
MissypCurrentLegalNoticeBody.Buffer);
}
} else {
MissypGreyLegalNotice( hwnd, TRUE );
}
//
// If changes aren't allowed, then grey the radio buttons
// and the text.
//
if (!ChangesAllowed) {
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_LEGAL_NOTICE_NONE);
EnableWindow( Control, FALSE );
Control = GetDlgItem(hwnd, MISSYP_ID_RADIO_LEGAL_NOTICE);
EnableWindow( Control, FALSE );
MissypGreyLegalNotice( hwnd, TRUE );
}
}
MissypOriginalLegalNotice = MissypCurrentLegalNotice;
MissypOriginalLegalNoticeChanged = FALSE;
return(TRUE);
}
VOID
MissypGreyLegalNotice(
HWND hwnd,
BOOLEAN Grey
)
/*++
Routine Description:
This function greys or ungreys the legal notice edit boxes.
Arguments
hwnd - Window handle.
Grey - If TRUE, the boxes will be greyed.
If FALSE, the boxes will be un-greyed.
Return Values:
None.
--*/
{
HWND
Control;
BOOLEAN
Enable;
if (Grey) {
Enable = FALSE;
} else {
Enable = TRUE;
}
Control = GetDlgItem(hwnd, MISSYP_ID_TEXT_LEGAL_NOTICE_TITLE_BAR);
EnableWindow( Control, Enable );
Control = GetDlgItem(hwnd, MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION);
EnableWindow( Control, Enable );
Control = GetDlgItem(hwnd, MISSYP_ID_TEXT_LEGAL_NOTICE_BODY);
EnableWindow( Control, Enable );
Control = GetDlgItem(hwnd, MISSYP_ID_EDIT_LEGAL_NOTICE_BODY);
InvalidateRect( Control, NULL, FALSE); // Required for multi-line edit boxes
EnableWindow( Control, Enable );
return;
}
VOID
MissypWarnOfAutologon(
HWND hwnd
)
/*++
Routine Description:
This function checks to see if autologon is turned on.
If it is, a warning is put up to warn the user. There is
no UI in this utility which allows the user to change this.
Therefore, tell the user how to do it with REGEDT32.
Arguments
hwnd - Window handle.
Return Values:
None.
--*/
{
if (GetProfileInt( TEXT("Winlogon"), TEXT("AutoAdminLogon"), 0 ) != 0) {
DialogBoxParam(MissypSecMgrhInstance,
MAKEINTRESOURCE(MISSYP_ID_DLG_WARNING_AUTOLOGON),
hwnd,
(DLGPROC)MissypDlgProcWarnOfAutologon,
(LONG)0
);
}
return;
}
LONG
MissypDlgProcWarnOfAutologon(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for a dialog informing the
user that autologon is enabled.
Arguments
Return Values:
--*/
{
HWND
OkButton;
int
Index;
switch (wMsg) {
case WM_INITDIALOG:
//
// Set the cursor
//
OkButton = GetDlgItem(hwnd, IDOK);
Index = (int)SendMessage(OkButton, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
break;
default:
return FALSE;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypSysAccApplyCurrentSettings(
IN HWND hwnd
)
/*++
Routine Description:
This function applies the current settings to the operational system.
If necessary, the RebootRequired flag will be set to TRUE.
Also, if necessary, a pop-up describing any problems will be
presented to the user.
Arguments
hwnd - Window handle.
Return Values:
TRUE - Everything was assigned correctly.
FALSE - Something was not assigned correctly. A popup has been
presented to the user.
--*/
{
BOOLEAN
Result = TRUE;
if (MissypCurrentLegalNotice == MISSYP_ID_RADIO_LEGAL_NOTICE_NONE) {
MissypCurrentLegalNoticeCaption.Length = 0;
MissypCurrentLegalNoticeCaption.Buffer[0] = TEXT('\0');
MissypCurrentLegalNoticeBody.Length = 0;
MissypCurrentLegalNoticeBody.Buffer[0] = TEXT('\0');
}
//
// We count on the called routines to put up appropriate
// pop-ups on error.
//
if (Result && (MissypCurrentUnlock != MissypOriginalUnlock)) {
Result = MissypSetUnlockSetting(hwnd, MissypCurrentUnlock);
}
if (Result && (MissypCurrentCacheSize != MissypOriginalCacheSize)) {
Result = MissypSetLogonCacheCount(hwnd, MissypCurrentCacheSize);
}
if (Result && (MissypOriginalLegalNoticeChanged)) {
Result = MissypSetLegalNotice(hwnd,
&MissypCurrentLegalNoticeCaption,
&MissypCurrentLegalNoticeBody);
}
if (Result && (MissypCurrentShutdown != MissypOriginalShutdown)) {
Result = MissypSetShutdownSetting(hwnd, MissypCurrentShutdown);
}
if (Result && (MissypCurrentLastName != MissypOriginalLastName)) {
if (MissypCurrentLastName == MISSYP_ID_RADIO_LASTNAME_DISPLAY) {
Result = MissypSetLastNameSetting(hwnd, TRUE); // TRUE => display
} else {
Result = MissypSetLastNameSetting(hwnd, FALSE); // FALSE => don't display
}
}
return(Result);
}
LONG
MissypDlgProcLastName(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the Display Last Name dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypLastNameInitDialog( hwnd, ChangesAllowed ) ) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
switch(LOWORD(wParam)) {
case MISSYP_ID_BUTTON_LASTNAME_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_LAST_USERNAME );
return(TRUE);
case MISSYP_ID_RADIO_LASTNAME_DISPLAY:
case MISSYP_ID_RADIO_LASTNAME_DONT_DISPLAY:
MissypCurrentLastName = LOWORD(wParam);
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypLastNameInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
)
/*++
Routine Description:
This function retrieves current values and recommended values
for this item. These values are set in both the
item control structures and in module-wide current-setting
variables.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// Update our values
//
if (MissypDisplayLastName( hwnd, ChangesAllowed, TRUE)) {
return(TRUE);
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
LONG
MissypDlgProcLogonCache(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the Logon Cache dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
WORD
NotificationCode,
ControlId;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypLogonCacheInitDialog( hwnd, ChangesAllowed )) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
//
// wParam WIN32- HIWORD = notification code,
// LOWORD = ID of control
// WIN16- ID of control
//
// lParam WIN32- hWnd of Control
// WIN16- HIWORD = notification code
// LOWORD = hWnd of control
//
//NotificationCode = GET_NOTIFY_MSG(wParam, lParam);
//ControlId = GET_CONTROL_ID(wParam);
NotificationCode = HIWORD(wParam);
ControlId = LOWORD(wParam);
switch(ControlId) {
case MISSYP_ID_BUTTON_LOGCAC_HINT:
MissypDisplayHint( hwnd, MISSYP_ID_DLG_HINT_LOGON_CACHE );
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
case WM_VSCROLL:
Index = GetWindowLong((HWND)lParam, GWL_ID);
switch (Index) {
case MISSYP_ID_SPIN_LOGCAC_APPLY:
Changed = FALSE;
if (LOWORD(wParam) == SB_LINEUP) {
if (MissypCurrentCacheSize < MISSYP_MAX_LOGON_CACHE_COUNT) {
MissypCurrentCacheSize++;
Changed = TRUE;
}
} else if (LOWORD(wParam) == SB_LINEDOWN) {
if (MissypCurrentCacheSize > 0) {
MissypCurrentCacheSize--;
Changed = TRUE;
}
}
if (Changed) {
SetDlgItemInt( hwnd,
MISSYP_ID_TEXT_LOGCAC_APPLY,
MissypCurrentCacheSize,
FALSE // Not signed value
);
}
return(TRUE);
default:
break;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypLogonCacheInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
)
/*++
Routine Description:
This function retrieves current values and recommended values
for this item. These values are set in both the
item control structures and in module-wide current-setting
variables.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// Update our values
//
if (MissypDisplayLogonCache( hwnd, ChangesAllowed, TRUE)) {
return(TRUE);
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
LONG
MissypDlgProcUnlock(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the Unlock Workstation dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
WORD
NotificationCode,
ControlId;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypUnlockInitDialog( hwnd, ChangesAllowed) ) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
//
// wParam WIN32- HIWORD = notification code,
// LOWORD = ID of control
// WIN16- ID of control
//
// lParam WIN32- hWnd of Control
// WIN16- HIWORD = notification code
// LOWORD = hWnd of control
//
//NotificationCode = GET_NOTIFY_MSG(wParam, lParam);
//ControlId = GET_CONTROL_ID(wParam);
NotificationCode = HIWORD(wParam);
ControlId = LOWORD(wParam);
switch(ControlId) {
case MISSYP_ID_RADIO_UNLOCK_ANYONE:
MissypCurrentUnlock = SecMgrAnyone;
return(TRUE);
case MISSYP_ID_RADIO_UNLOCK_ADMIN:
MissypCurrentUnlock = SecMgrAdminsOnly;
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypUnlockInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
)
/*++
Routine Description:
This function retrieves current values and recommended values
for this item. These values are set in both the
item control structures and in module-wide current-setting
variables.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// Update our values
//
if (MissypDisplayUnlock( hwnd, ChangesAllowed, TRUE)) {
return(TRUE);
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
LONG
MissypDlgProcShutdown(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the System Shutdown dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
WORD
NotificationCode,
ControlId;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypShutdownInitDialog( hwnd, ChangesAllowed) ) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_SYSCOMMAND:
switch (wParam & 0xfff0) {
case SC_CLOSE:
EndDialog(hwnd, 0);
return(TRUE);
}
return(FALSE);
case WM_COMMAND:
//
// wParam WIN32- HIWORD = notification code,
// LOWORD = ID of control
// WIN16- ID of control
//
// lParam WIN32- hWnd of Control
// WIN16- HIWORD = notification code
// LOWORD = hWnd of control
//
//NotificationCode = GET_NOTIFY_MSG(wParam, lParam);
//ControlId = GET_CONTROL_ID(wParam);
NotificationCode = HIWORD(wParam);
ControlId = LOWORD(wParam);
switch(ControlId) {
case MISSYP_ID_RADIO_SHUTDOWN_ANYONE:
MissypCurrentShutdown = SecMgrAnyone;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_LOGGED_ON:
MissypCurrentShutdown = SecMgrAnyoneLoggedOn;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_OPERS:
MissypCurrentShutdown = SecMgrOpersAndAdmins;
return(TRUE);
case MISSYP_ID_RADIO_SHUTDOWN_ADMIN:
MissypCurrentShutdown = SecMgrAdminsOnly;
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypShutdownInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
)
/*++
Routine Description:
This function retrieves current values and recommended values
for this item. These values are set in both the
item control structures and in module-wide current-setting
variables.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// Update our values
//
if (MissypDisplayShutdown( hwnd, ChangesAllowed, TRUE)) {
return(TRUE);
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
LONG
MissypDlgProcLegalNotice(
HWND hwnd,
UINT wMsg,
DWORD wParam,
LONG lParam
)
/*++
Routine Description:
This function is the dialog process for the Legal Notice dialog.
Arguments
lParam - If FALSE, changes are NOT allowed to any of the settings.
If TRUE, changes ARE allowed.
Return Values:
TRUE - the message was handled.
FALSE - the message was not handled.
--*/
{
HWND
Button;
HCURSOR
hCursor;
WORD
NotificationCode,
ControlId;
int
Index;
BOOLEAN
ChangesAllowed,
Changed;
ChangesAllowed = (BOOLEAN)(lParam);
switch (wMsg) {
case WM_INITDIALOG:
if (!MissypLegalNoticeInitDialog( hwnd, ChangesAllowed) ) {
//
// Couldn't init the dialog. It has been terminated.
//
return(TRUE);
}
//
// If ChangesAllowed, Hide the [OK] button.
// Otherwise, hide the [APPLY] and [CANCEL] buttons.
// Also select the button for the cursor to start at.
//
if (ChangesAllowed) {
Button = GetDlgItem(hwnd, IDOK);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
} else {
Button = GetDlgItem(hwnd, MISSYP_ID_BUTTON_APPLY);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDCANCEL);
ShowWindow( Button, SW_HIDE );
Button = GetDlgItem(hwnd, IDOK);
}
//
// Set the cursor
//
Index = (int)SendMessage(Button, CB_GETCURSEL, 0, 0);
SetForegroundWindow(hwnd);
ShowWindow(hwnd, SW_NORMAL);
return(TRUE);
case WM_COMMAND:
//
// wParam WIN32- HIWORD = notification code,
// LOWORD = ID of control
// WIN16- ID of control
//
// lParam WIN32- hWnd of Control
// WIN16- HIWORD = notification code
// LOWORD = hWnd of control
//
//NotificationCode = GET_NOTIFY_MSG(wParam, lParam);
//ControlId = GET_CONTROL_ID(wParam);
NotificationCode = HIWORD(wParam);
ControlId = LOWORD(wParam);
switch(ControlId) {
case MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION:
case MISSYP_ID_EDIT_LEGAL_NOTICE_BODY:
//
// Just note that the notice has changed
//
if (NotificationCode == EN_UPDATE) {
MissypOriginalLegalNoticeChanged = TRUE;
}
return(TRUE);
case MISSYP_ID_BUTTON_APPLY:
//
// Changing some of the values takes
// a while. Change to an hourglass icon.
//
hCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
ShowCursor(TRUE);
//
// Get the legal notice strings, if necessary
//
if (MissypOriginalLegalNoticeChanged) {
if (MissypCurrentLegalNotice == MISSYP_ID_RADIO_LEGAL_NOTICE ) {
MissypCurrentLegalNoticeCaption.Length =
GetDlgItemText(hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_CAPTION,
MissypCurrentLegalNoticeCaption.Buffer,
MissypCurrentLegalNoticeCaption.MaximumLength
);
MissypCurrentLegalNoticeBody.Length =
GetDlgItemText(hwnd,
MISSYP_ID_EDIT_LEGAL_NOTICE_BODY,
MissypCurrentLegalNoticeBody.Buffer,
MissypCurrentLegalNoticeBody.MaximumLength
);
}
}
if (MissypSysAccApplyCurrentSettings( hwnd )) {
EndDialog(hwnd, 0);
}
return(TRUE);
case MISSYP_ID_RADIO_LEGAL_NOTICE_NONE:
MissypGreyLegalNotice( hwnd, TRUE );
MissypCurrentLegalNotice = LOWORD(wParam);
if (MissypOriginalLegalNotice != MissypCurrentLegalNotice) {
MissypOriginalLegalNoticeChanged = TRUE;
} else {
MissypOriginalLegalNoticeChanged = FALSE;
}
return(TRUE);
case MISSYP_ID_RADIO_LEGAL_NOTICE:
MissypGreyLegalNotice( hwnd, FALSE );
MissypCurrentLegalNotice = LOWORD(wParam);
//
// If the original setting was "LEGAL NOTICE", we can't
// say that the original notice hasn't changed if we
// re-select this button. This is because the text of
// the message might have changed.
//
if (MissypOriginalLegalNotice != MissypCurrentLegalNotice) {
MissypOriginalLegalNoticeChanged = TRUE;
}
return(TRUE);
case IDCANCEL:
case IDOK:
EndDialog(hwnd, 0);
return(TRUE);
default:
return FALSE;
}
default:
break;
}
return FALSE;
}
BOOLEAN
MissypLegalNoticeInitDialog(
IN HWND hwnd,
IN BOOL ChangesAllowed
)
/*++
Routine Description:
This function retrieves current values and recommended values
for this item. These values are set in both the
item control structures and in module-wide current-setting
variables.
For Read-Only operations, the caller is responsible for greying
all controls in the dialog box (except the [HELP] button) and
making the [APPLY] and [CANCEL] buttons invisible.
For Read-Write operations, the caller is responsible for making the
[OK] button invisible.
Arguments
hwnd - dialog handle
ChangesAllowed - TRUE: Leave change controls enabled.
FALSE: Disable change controls.
Return Values:
TRUE - The dialog has been initialized without problem.
FALSE - A problem was encountered. A popup has been displayed
and the dialog has been ended.
--*/
{
///////////////////////////////////////////////////////////////////
// //
// Get current settings and recommended settings. //
// //
///////////////////////////////////////////////////////////////////
//
// Update our values
//
if (MissypDisplayLegalNotice( hwnd, ChangesAllowed, TRUE)) {
return(TRUE);
}
//
// Something didn't work
//
EndDialog(hwnd, 0);
return(FALSE);
}
Reference in New Issue Copy Permalink