able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/netui/liccpa/licsetup.cpp

1875 lines
52 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation.
All rights reserved
Module Name:
licsetup.cpp
Abstract:
This module exports a function, LicenseSetupRequestWizardPages, which
gives NT Setup a wizard page for licensing to use in system setup (if
licensing should be installed).
This wizard page is responsible for all license system configuration,
including:
o Creating the LicenseService
o Creating the ...\CurrentControlSet\Services\LicenseService key and
its values. (This key contains all configuration information for the
LicenseService.)
o Creating the ...\CurrentControlSet\Services\LicenseInfo key and its
values. (This key contains all product-specific license info.)
o Creating the appropriate registry key to register the LicenseService
with the EventLog.
Portions of this module were extracted from SETUP (specifically from
\nt\private\windows\setup\syssetup\license.c).
Author:
Jeff Parham (jeffparh) 15-Apr-1996
Revision History:
Jeff Parham (jeffparh) 17-Jul-1997
Added KSecDD to FilePrint services table for SFM
--*/
#include <windows.h>
#include <commctrl.h>
#include <setupapi.h>
#include <syssetup.h>
#include <setupbat.h>
#include <stdlib.h>
#include <htmlhelp.h>
#include <Accctrl.h>
#include <aclapi.h>
#include "liccpa.hpp"
#include "help.hpp"
#include "clicreg.hpp"
#include "config.hpp"
#include "resource.h"
#include "pridlgs.hpp"
#include "special.hpp"
//============================================================================
//
// MACROS
//
// used by setup tests? simulates a click on the NEXT button
#define WM_SIMULATENEXT ( WM_USER + 287 )
// begin or end a wait cursor
#define WM_BEGINWAITCURSOR ( WM_USER + 300 )
#define WM_ENDWAITCURSOR ( WM_USER + 301 )
// number of license wizard pages
const DWORD NUM_LICENSE_PAGES = 1;
// limits for per server licenses entered from the edit box in the
// license mode page
const int PERSERVER_EDIT_MAX = 9999;
const int PERSERVER_EDIT_MIN = 5;
// the number of chars to represent PERSERVER_EDIT_MAX
const int PERSERVER_EDIT_WIDTH = 4;
//============================================================================
//
// LOCAL PROTOTYPES
//
// decides, based on the setup type, whether licensing is installed
static BOOL LicenseSetupDisplayLicensePagesQuery( PINTERNAL_SETUP_DATA );
// License mode page functions
static HPROPSHEETPAGE LicenseSetupModePageGet( PINTERNAL_SETUP_DATA );
static INT_PTR CALLBACK LicenseSetupModeDlgProc( HWND, UINT, WPARAM, LPARAM );
// License mode page Windows message handlers
static void LicenseSetupModeOnInitDialog( HWND, LPARAM, PINTERNAL_SETUP_DATA *, LPBOOL, LPDWORD, LPDWORD );
static void LicenseSetupModeOnSetActive( HWND, PINTERNAL_SETUP_DATA, LPBOOL, LPDWORD );
static void LicenseSetupModeOnSetLicenseMode( HWND, BOOL, DWORD );
static void LicenseSetupModeOnEditUpdate( HWND, HWND, BOOL, LPDWORD );
static void LicenseSetupModeOnWaitCursor( HWND, BOOL, LPDWORD );
static BOOL LicenseSetupModeOnSetCursor( HWND, WORD, DWORD );
static void LicenseSetupModeOnNext( HWND, PINTERNAL_SETUP_DATA, BOOL, DWORD );
static void LicenseSetupModeOnHelp( HWND );
static void LicenseSetupModeOnSimulateNext( HWND );
static void LicenseSetupModeOnKillActive( HWND );
static BOOL LicenseSetupModeDoUnattended( HWND, PINTERNAL_SETUP_DATA, LPBOOL, LPDWORD );
// License configuration save functions
static DWORD LicenseSetupWrite( BOOL, DWORD );
static DWORD LicenseSetupWriteKeyLicenseInfo( BOOL, DWORD );
static DWORD LicenseSetupWriteKeyLicenseService( BOOL fWriteParametersKey );
static DWORD LicenseSetupWriteKeyEventLog();
static DWORD LicenseSetupWriteService( BOOL * fCreated );
// utility functions
static int MessageBoxFromStringID( HWND, UINT, UINT, UINT );
void CreateDirectoryWithAccess();
void CreateFileWithAccess();
BOOL IsRestrictedSmallBusSrv( void );
#define SBS_SPECIAL_USERS 10
//============================================================================
//
// GLOBAL IMPLEMENTATION
//
BOOL
APIENTRY
LicenseSetupRequestWizardPages(
HPROPSHEETPAGE * paPropSheetPages,
UINT * pcPages,
PINTERNAL_SETUP_DATA pSetupData )
{
BOOL fSuccess = FALSE;
BOOL fDisplayLicensePages;
// validate params
if ( ( NULL != pcPages )
&& ( NULL != pSetupData )
&& ( sizeof( INTERNAL_SETUP_DATA ) == pSetupData->dwSizeOf ) )
{
fDisplayLicensePages = LicenseSetupDisplayLicensePagesQuery( pSetupData );
if ( NULL == paPropSheetPages )
{
// request for number of pages only
*pcPages = fDisplayLicensePages ? NUM_LICENSE_PAGES : 0;
fSuccess = TRUE;
}
else
{
// request for actual pages
if ( !fDisplayLicensePages )
{
// no pages needed
*pcPages = 0;
fSuccess = TRUE;
}
else if ( *pcPages >= NUM_LICENSE_PAGES )
{
// create and return pages
paPropSheetPages[ 0 ] = LicenseSetupModePageGet( pSetupData );
if ( NULL != paPropSheetPages[ 0 ] )
{
*pcPages = NUM_LICENSE_PAGES;
fSuccess = TRUE;
}
}
}
}
return fSuccess;
}
//============================================================================
//
// LOCAL IMPLEMENTATIONS
//
static
BOOL
LicenseSetupDisplayLicensePagesQuery(
PINTERNAL_SETUP_DATA pSetupData )
//
// The following code was extracted and modified from
// \nt\private\windows\setup\syssetup\license.c
// in setup. It returns TRUE iff the licensing wizard pages should be
// displayed as a part of setup.
//
{
BOOL fDisplayLicensePages;
if ( PRODUCT_WORKSTATION == pSetupData->ProductType )
{
//
// If installing a workstation, then do not display the licensing page
//
fDisplayLicensePages = FALSE;
}
else
{
if ( !( pSetupData->OperationFlags & SETUPOPER_NTUPGRADE ) )
{
//
// The licensing page needs to be displayed on a clean install
// of a server
//
fDisplayLicensePages = TRUE;
}
else
{
//
// If upgrading a server, find out if it was already licensed
// (NT 3.51 and later). If it was, then do not display the
// licensing page.
// We find out whether or not the system was licensed by looking
// at a value entry in the registry.
// Note that NT 3.1 and 3.5 will never have this value in the
// registry, and in these cases the licensing page needs to be
// displayed.
//
DWORD winStatus;
CLicRegLicenseService FilePrintService( FILEPRINT_SERVICE_REG_KEY );
winStatus = FilePrintService.Open( NULL, FALSE );
if ( ERROR_SUCCESS != winStatus )
{
fDisplayLicensePages = TRUE;
}
else
{
LICENSE_MODE LicenseMode;
winStatus = FilePrintService.GetMode( LicenseMode );
if ( ( ERROR_SUCCESS != winStatus )
|| ( ( LICMODE_PERSEAT != LicenseMode )
&& ( LICMODE_PERSERVER != LicenseMode ) ) )
{
fDisplayLicensePages = TRUE;
}
else
{
// set FlipAllow value if it's not already set (a setup bug in
// the betas of NT 4.0 caused this value to be absent)
FilePrintService.CanChangeMode();
// add KSecDD to FilePrint services table if it isn't there already
HKEY hkeySFM;
DWORD dwDisposition;
winStatus = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
TEXT( "System\\CurrentControlSet\\Services\\LicenseService\\FilePrint\\KSecDD" ),
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hkeySFM,
&dwDisposition );
if ( ERROR_SUCCESS == winStatus )
{
RegCloseKey( hkeySFM );
}
// Change FilePrint License name from Windows NT to Windows.
CLicRegLicenseService FilePrintService(
FILEPRINT_SERVICE_REG_KEY );
winStatus = FilePrintService.Open( NULL, FALSE );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetFamilyDisplayName(
FILEPRINT_SERVICE_FAMILY_DISPLAY_NAME );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetDisplayName(
FILEPRINT_SERVICE_DISPLAY_NAME );
}
}
//
// makarp: setting fDisplayLicensePages to true is wrong, because in such case
// the pages will be displayed, and the original settings will be lost.
//
// fDisplayLicensePages = TRUE;
//
// instead we do the stuff we want to explicitely here.
//
BOOL bFlag = FALSE;
LicenseSetupWriteService(&bFlag);
CreateDirectoryWithAccess();
CreateFileWithAccess();
fDisplayLicensePages = FALSE;
}
}
}
}
return fDisplayLicensePages;
}
static
HPROPSHEETPAGE
LicenseSetupModePageGet(
PINTERNAL_SETUP_DATA pSetupData )
//
// Returns an HPROPSHEETPAGE for the license mode wizard page, or
// NULL if error.
//
{
HPROPSHEETPAGE hpsp;
PROPSHEETPAGE psp;
TCHAR szHeader[256];
TCHAR szSubHeader[512];
psp.dwSize = sizeof( psp );
psp.dwFlags = PSP_USETITLE | PSP_HASHELP | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hinst;
psp.pszTemplate = MAKEINTRESOURCE( IDD_SETUP_LICENSE_MODE_PAGE );
psp.hIcon = NULL;
psp.pfnDlgProc = LicenseSetupModeDlgProc;
psp.lParam = (LPARAM) pSetupData;
psp.pszTitle = pSetupData->WizardTitle;
szHeader[0] = L'\0';
szSubHeader[0] = L'\0';
LoadString( g_hinst,
IDS_SETUP_HEADER,
szHeader,
sizeof( szHeader ) / sizeof( *szHeader ) );
LoadString( g_hinst,
IDS_SETUP_SUBHEADER,
szSubHeader,
sizeof( szSubHeader ) / sizeof( *szSubHeader ) );
psp.pszHeaderTitle = szHeader;
psp.pszHeaderSubTitle = szSubHeader;
hpsp = CreatePropertySheetPage( &psp );
return hpsp;
}
static
INT_PTR
CALLBACK
LicenseSetupModeDlgProc(
HWND hwndPage,
UINT msg,
WPARAM wParam,
LPARAM lParam )
//
// Dialog procedure for the license mode wizard page.
//
{
// static data initialized by WM_INITDIALOG
static PINTERNAL_SETUP_DATA pSetupData = NULL;
static BOOL fLicensePerServer;
static DWORD cPerServerLicenses;
static DWORD cWaitCursor;
BOOL fReturn = TRUE;
switch ( msg )
{
case WM_INITDIALOG:
LicenseSetupModeOnInitDialog( hwndPage, lParam, &pSetupData, &fLicensePerServer, &cPerServerLicenses, &cWaitCursor );
break;
case WM_SIMULATENEXT:
LicenseSetupModeOnSimulateNext( hwndPage );
break;
case WM_BEGINWAITCURSOR:
LicenseSetupModeOnWaitCursor( hwndPage, TRUE, &cWaitCursor );
break;
case WM_ENDWAITCURSOR:
LicenseSetupModeOnWaitCursor( hwndPage, FALSE, &cWaitCursor );
break;
case WM_SETCURSOR:
LicenseSetupModeOnSetCursor( hwndPage, LOWORD( lParam ), cWaitCursor );
break;
case WM_COMMAND:
switch ( HIWORD( wParam ) )
{
case BN_CLICKED:
switch ( LOWORD( wParam ) )
{
case IDC_PERSEAT:
fLicensePerServer = FALSE;
LicenseSetupModeOnSetLicenseMode( hwndPage, fLicensePerServer, cPerServerLicenses );
break;
case IDC_PERSERVER:
fLicensePerServer = TRUE;
LicenseSetupModeOnSetLicenseMode( hwndPage, fLicensePerServer, cPerServerLicenses );
break;
}
break;
case EN_UPDATE:
if ( IDC_USERCOUNT == LOWORD( wParam ) )
{
LicenseSetupModeOnEditUpdate( hwndPage, (HWND) lParam, fLicensePerServer, &cPerServerLicenses );
}
break;
default:
fReturn = FALSE;
break;
}
break;
case WM_NOTIFY:
{
NMHDR * pNmHdr;
pNmHdr = (NMHDR *)lParam;
switch ( pNmHdr->code )
{
case PSN_SETACTIVE:
LicenseSetupModeOnSetActive( hwndPage, pSetupData, &fLicensePerServer, &cPerServerLicenses );
break;
case PSN_KILLACTIVE:
LicenseSetupModeOnKillActive( hwndPage );
break;
case PSN_WIZNEXT:
case PSN_WIZFINISH:
LicenseSetupModeOnNext( hwndPage, pSetupData, fLicensePerServer, cPerServerLicenses );
break;
case PSN_HELP:
LicenseSetupModeOnHelp( hwndPage );
break;
default:
fReturn = FALSE;
break;
}
}
break;
default:
fReturn = FALSE;
}
return fReturn;
}
static
void
LicenseSetupModeOnInitDialog(
HWND hwndPage,
LPARAM lParam,
PINTERNAL_SETUP_DATA * ppSetupData,
LPBOOL pfLicensePerServer,
LPDWORD pcPerServerLicenses,
LPDWORD pcWaitCursor )
//
// Message handler for WM_INITDIALOG
//
{
// initialize static data
*ppSetupData = (PINTERNAL_SETUP_DATA) ( (LPPROPSHEETPAGE) lParam )->lParam;
*pcPerServerLicenses = 5;
*pfLicensePerServer = TRUE;
*pcWaitCursor = 0;
// limit license count edit text length
SendMessage( GetDlgItem( hwndPage, IDC_USERCOUNT ), EM_LIMITTEXT, PERSERVER_EDIT_WIDTH, 0 );
// limit license count up-down range
LONG lRange;
lRange = (LPARAM) MAKELONG( (short) PERSERVER_EDIT_MAX, (short) PERSERVER_EDIT_MIN );
SendMessage( GetDlgItem( hwndPage, IDC_USERCOUNTARROW ), UDM_SETRANGE, 0, (LPARAM) lRange );
// initialize for default license mode
LicenseSetupModeOnSetLicenseMode( hwndPage, *pfLicensePerServer, *pcPerServerLicenses );
}
static
void
LicenseSetupModeOnSetActive(
HWND hwndPage,
PINTERNAL_SETUP_DATA pSetupData,
LPBOOL pfLicensePerServer,
LPDWORD pcPerServerLicenses )
//
// Notification handler for PSN_SETACTIVE
//
{
static BOOL fFirstTime = TRUE;
BOOL fSkipPage;
#ifdef SPECIAL_USERS
*pfLicensePerServer = TRUE;
*pcPerServerLicenses = SPECIAL_USERS;
fSkipPage = TRUE;
#else
if ( IsRestrictedSmallBusSrv() )
{
*pfLicensePerServer = TRUE;
*pcPerServerLicenses = SBS_SPECIAL_USERS;
fSkipPage = TRUE;
}
else if ( pSetupData->OperationFlags & SETUPOPER_BATCH )
{
// operating in unattended mode; attempt to get all answers
// from the unattend configuration file
fSkipPage = LicenseSetupModeDoUnattended( hwndPage,
pSetupData,
pfLicensePerServer,
pcPerServerLicenses );
if ( !fSkipPage )
{
// Set defaults from unattended file
LicenseSetupModeOnSetLicenseMode( hwndPage,
*pfLicensePerServer,
*pcPerServerLicenses );
//
// makarp: setting skippage to true is wrong, because we do not want to skip page.
// we came here because we did not find sufficent answers in answer file.
//
// fSkipPage = TRUE;
}
}
else
{
// operating in interactive mode; get answers from user
fSkipPage = FALSE;
}
#endif
HWND hwndSheet = GetParent( hwndPage );
if ( fSkipPage )
{
if (fFirstTime)
{
fFirstTime = FALSE;
// skip page
// Only the first time do we need to do the processing which happens on next
PostMessage( hwndSheet, PSM_PRESSBUTTON, (WPARAM)PSBTN_NEXT, 0 );
}
else
{
// After the first time the processing is already done and we don't have to do anything
// This also solves the problem where the page needs to be skipped when the user clicks back
// on a later page and this pages needs to be skipped.
SetWindowLongPtr( hwndPage, DWLP_MSGRESULT, (LONG_PTR)-1 );
return;
}
}
else
{
// display page
// hide Cancel button
HWND hwndCancel = GetDlgItem( hwndSheet, IDCANCEL );
EnableWindow( hwndCancel, FALSE);
ShowWindow( hwndCancel, SW_HIDE);
PropSheet_SetWizButtons( hwndSheet, PSWIZB_NEXT | PSWIZB_BACK );
if (pSetupData)
{
pSetupData->ShowHideWizardPage(TRUE);
}
}
// success
SetWindowLongPtr( hwndPage, DWLP_MSGRESULT, (LONG_PTR)0 );
}
static
void
LicenseSetupModeOnSetLicenseMode(
HWND hwndPage,
BOOL fToPerServer,
DWORD cPerServerLicenses )
//
// Handles changing the page to signify that the given license mode
// is selected.
//
{
HWND hwndCount = GetDlgItem( hwndPage, IDC_USERCOUNT );
HWND hwndSpin = GetDlgItem( hwndPage, IDC_USERCOUNTARROW );
// set radio button states
CheckDlgButton( hwndPage, IDC_PERSEAT, !fToPerServer );
CheckDlgButton( hwndPage, IDC_PERSERVER, fToPerServer );
// set user count edit control
if ( fToPerServer )
{
// display per server count
SetDlgItemInt( hwndPage, IDC_USERCOUNT, cPerServerLicenses, FALSE );
SetFocus( hwndCount );
SendMessage( hwndCount, EM_SETSEL, 0, -1 );
}
else
{
// remove per server count
SetDlgItemText( hwndPage, IDC_USERCOUNT, TEXT( "" ) );
}
// display count up-down and edit box iff per server mode is selected
EnableWindow( hwndCount, fToPerServer );
EnableWindow( hwndSpin, fToPerServer );
}
static
void
LicenseSetupModeOnEditUpdate(
HWND hwndPage,
HWND hwndCount,
BOOL fLicensePerServer,
LPDWORD pcPerServerLicenses )
//
// Command handler for EN_UPDATE of count edit box
//
{
if ( fLicensePerServer )
{
BOOL fTranslated;
UINT nValue;
BOOL fModified = FALSE;
nValue = GetDlgItemInt( hwndPage, IDC_USERCOUNT, &fTranslated, FALSE );
if ( fTranslated )
{
// count translated; ensure its within the valid range
if ( PERSERVER_EDIT_MAX < nValue )
{
// too big
nValue = PERSERVER_EDIT_MAX;
fModified = TRUE;
}
*pcPerServerLicenses = nValue;
}
else
{
// count couldn't be translated; reset to last value
nValue = *pcPerServerLicenses;
fModified = TRUE;
}
if ( fModified )
{
// text in edit box is invalid; change it to the proper value
SetDlgItemInt( hwndPage, IDC_USERCOUNT, nValue, FALSE );
SetFocus( hwndCount );
SendMessage( hwndCount, EM_SETSEL, 0, -1 );
MessageBeep( MB_VALUELIMIT );
}
}
}
static
void
LicenseSetupModeOnWaitCursor(
HWND hwndDlg,
BOOL fWait,
LPDWORD pcWaitCursor )
//
// Handler for WM_BEGINWAITCURSOR / WM_ENDWAITCURSOR
//
{
if ( fWait )
{
(*pcWaitCursor)++;
if ( 1 == (*pcWaitCursor) )
{
// display wait cursor
SetCursor( LoadCursor( NULL, MAKEINTRESOURCE( IDC_WAIT ) ) );
}
}
else
{
if ( 0 < *pcWaitCursor )
{
(*pcWaitCursor)--;
}
if ( 0 == *pcWaitCursor )
{
// display regular cursor
SetCursor( LoadCursor( NULL, MAKEINTRESOURCE( IDC_ARROW ) ) );
}
}
// success
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, (LONG_PTR)*pcWaitCursor );
}
static
BOOL
LicenseSetupModeOnSetCursor(
HWND hwndDlg,
WORD nHitTest,
DWORD cWaitCursor )
//
// Handler for WM_SETCURSOR
//
{
BOOL frt = FALSE;
if ( HTCLIENT == nHitTest )
{
if ( cWaitCursor > 0 )
{
// display wait cursor instead of regular cursor
SetCursor( LoadCursor( NULL, MAKEINTRESOURCE( IDC_WAIT ) ) );
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, (LONG_PTR)TRUE );
frt = TRUE;
}
}
return frt;
}
static
void
LicenseSetupModeOnNext(
HWND hwndPage,
PINTERNAL_SETUP_DATA pSetupData,
BOOL fLicensePerServer,
DWORD cPerServerLicenses )
//
// Notification handler for PSN_WIZNEXT
//
{
DWORD winStatus;
int nButton;
if ( ( fLicensePerServer )
&& ( PERSERVER_EDIT_MIN > cPerServerLicenses )
&& !( pSetupData->OperationFlags & SETUPOPER_BATCH ) )
{
// warn user about using per server mode with less then 5 licenses
MessageBoxFromStringID( hwndPage,
IDS_LICENSE_SETUP_NO_PER_SERVER_LICENSES,
IDS_WARNING,
MB_ICONERROR | MB_OK );
nButton = IDCANCEL;
}
else
{
// per seat mode or per server mode with positive license count
nButton = IDOK;
}
if ( IDOK == nButton )
{
do
{
// save license configuration
SendMessage( hwndPage, WM_BEGINWAITCURSOR, 0, 0 );
winStatus = LicenseSetupWrite( fLicensePerServer, cPerServerLicenses );
SendMessage( hwndPage, WM_ENDWAITCURSOR, 0, 0 );
if ( ERROR_SUCCESS != winStatus )
{
// save failed; alert user
nButton = MessageBoxFromStringID( hwndPage,
IDS_LICENSE_SETUP_SAVE_FAILED,
IDS_ERROR,
MB_ICONSTOP | MB_ABORTRETRYIGNORE | MB_DEFBUTTON2 );
if ( IDIGNORE == nButton )
{
nButton = IDOK;
}
}
else
{
// save succeeded
nButton = IDOK;
}
} while ( IDRETRY == nButton );
}
if ( IDOK != nButton )
{
// don't advance to next page
SetWindowLongPtr( hwndPage, DWLP_MSGRESULT, (LONG_PTR)-1 );
}
}
static
void
LicenseSetupModeOnHelp(
HWND hwndPage )
//
// Notification handler for PSN_HELP
//
{
::HtmlHelp( hwndPage, LICCPA_HTMLHELPFILE, HH_DISPLAY_TOPIC,0);
}
static
void
LicenseSetupModeOnSimulateNext(
HWND hwndPage )
//
// Handler for WM_SIMULATENEXT (used by setup tests?)
//
{
// simulate the next button
PropSheet_PressButton( GetParent( hwndPage ), PSBTN_NEXT );
}
static
void
LicenseSetupModeOnKillActive(
HWND hwndPage )
//
// Notification handler for PSN_KILLACTIVE
//
{
// success
SetWindowLong( hwndPage, DWLP_MSGRESULT, 0);
}
typedef enum {
UnattendFullUnattend,
UnattendGUIAttended,
UnattendDefaultHide,
UnattendProvideDefault,
UnattendReadOnly } UNATTENDMODE;
static
BOOL
LicenseSetupModeDoUnattended(
HWND hwndPage,
PINTERNAL_SETUP_DATA pSetupData,
LPBOOL pfLicensePerServer,
LPDWORD pcPerServerLicenses )
//
// Get answers to wizard page from unattend file.
//
{
int cch;
LPTSTR pszBadParam;
TCHAR szLicenseMode[ 64 ];
TCHAR szPerServerLicenses[ 64 ];
TCHAR szUnattendMode[ 64 ];
UNATTENDMODE UnattendMode = UnattendDefaultHide;
pszBadParam = NULL;
SendMessage( hwndPage, WM_BEGINWAITCURSOR, 0, 0 );
// Get Unattend Mode
cch = GetPrivateProfileString( WINNT_UNATTENDED,
WINNT_U_UNATTENDMODE,
TEXT( "" ),
szUnattendMode,
sizeof( szUnattendMode ) / sizeof( *szUnattendMode ),
pSetupData->UnattendFile );
if ( 0 < cch )
{
if ( !lstrcmpi( szUnattendMode, WINNT_A_FULLUNATTENDED ) )
{
UnattendMode = UnattendFullUnattend;
}
else if ( !lstrcmpi( szUnattendMode, WINNT_A_PROVIDEDEFAULT ) )
{
UnattendMode = UnattendProvideDefault;
}
else if ( !lstrcmpi( szUnattendMode, WINNT_A_READONLY ) )
{
UnattendMode = UnattendReadOnly;
}
else if ( !lstrcmpi( szUnattendMode, WINNT_A_GUIATTENDED ) )
{
// This should never happen
UnattendMode = UnattendGUIAttended;
}
}
// get license mode
cch = GetPrivateProfileString( WINNT_LICENSEDATA_W,
WINNT_L_AUTOMODE_W,
TEXT( "" ),
szLicenseMode,
sizeof( szLicenseMode ) / sizeof( *szLicenseMode ),
pSetupData->UnattendFile );
SendMessage( hwndPage, WM_ENDWAITCURSOR, 0, 0 );
if ( 0 < cch )
{
if ( !lstrcmpi( szLicenseMode, WINNT_A_PERSEAT_W ) )
{
*pfLicensePerServer = FALSE;
}
else if ( !lstrcmpi( szLicenseMode, WINNT_A_PERSERVER_W ) )
{
*pfLicensePerServer = TRUE;
}
else
{
cch = 0;
}
}
if ( cch <= 0 )
{
// license mode absent or invalid
pszBadParam = WINNT_L_AUTOMODE_W;
}
else if ( !*pfLicensePerServer )
{
// per seat mode; no need to read per server license count
*pcPerServerLicenses = 0;
}
else
{
// get per server license count
SendMessage( hwndPage, WM_BEGINWAITCURSOR, 0, 0 );
cch = GetPrivateProfileString( WINNT_LICENSEDATA_W,
WINNT_L_AUTOUSERS_W,
TEXT( "" ),
szPerServerLicenses,
sizeof( szPerServerLicenses ) / sizeof( *szPerServerLicenses ),
pSetupData->UnattendFile );
SendMessage( hwndPage, WM_ENDWAITCURSOR, 0, 0 );
if ( 0 < cch )
{
*pcPerServerLicenses = wcstoul( szPerServerLicenses, NULL, 10 );
if ( ( PERSERVER_EDIT_MIN > *pcPerServerLicenses )
|| ( PERSERVER_EDIT_MAX < *pcPerServerLicenses ) )
{
// Don't let things go without setting a valid server license
// count.
*pcPerServerLicenses = PERSERVER_EDIT_MIN;
cch = 0;
}
}
if ( cch <= 0 )
{
// per server license count absent or invalid
pszBadParam = WINNT_L_AUTOUSERS_W;
}
}
//
// Do not display the error message on preinstall.
//
if ( NULL != pszBadParam &&
!(pSetupData->OperationFlags & (SETUPOPER_PREINSTALL | SETUPOPER_NTUPGRADE)) &&
UnattendMode == UnattendFullUnattend )
{
// encountered a bad unattended parameter; display error
TCHAR szCaption[ 64 ];
TCHAR szFormat[ 1024 ];
TCHAR szText[ 1024 ];
LoadString( g_hinst,
IDS_LICENSE_SETUP_BAD_UNATTEND_PARAM,
szFormat,
sizeof( szFormat ) / sizeof( *szFormat ) );
LoadString( g_hinst,
IDS_ERROR,
szCaption,
sizeof( szCaption ) / sizeof( *szCaption ) );
wsprintf( szText, szFormat, pszBadParam );
MessageBox( hwndPage,
szText,
szCaption,
MB_OK | MB_ICONSTOP );
}
// If just providing defaults, return FALSE to force the page to show
if ( UnattendMode == UnattendProvideDefault )
return ( FALSE );
return ( NULL == pszBadParam );
}
static
DWORD
LicenseSetupWrite(
BOOL fLicensePerServer,
DWORD cPerServerLicenses )
//
// Write license configuration; returns ERROR_SUCCESS or Windows error.
//
{
DWORD winStatus;
BOOL fCreated = TRUE; // TRUE if service entry is created
// Used to determine if we should create
// the parameters key or leave it alone.
winStatus = LicenseSetupWriteService( &fCreated );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = LicenseSetupWriteKeyLicenseInfo( fLicensePerServer,
cPerServerLicenses );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = LicenseSetupWriteKeyLicenseService( fCreated );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = LicenseSetupWriteKeyEventLog();
}
}
}
return winStatus;
}
static
DWORD
LicenseSetupWriteKeyLicenseInfo(
BOOL fLicensePerServer,
DWORD cPerServerLicenses )
//
// Create registry values:
//
// HKEY_LOCAL_MACHINE
// \System
// \CurrentControlSet
// \Services
// \LicenseInfo
// ErrorControl : REG_DWORD : 1
// Start : REG_DWORD : 3
// Type : REG_DWORD : 4
// \FilePrint
// ConcurrentLimit : REG_DWORD : fLicensePerServer ? cPerServerLicenses : 0
// DisplayName : REG_SZ : "Windows Server"
// FamilyDisplayName : REG_SZ : "Windows Server"
// Mode : REG_DWORD : fLicensePerServer ? 1 : 0
// FlipAllow : REG_DWORD : fLicensePerServer ? 1 : 0
//
{
DWORD winStatus;
BOOL fCreatedNewServiceList;
CLicRegLicense ServiceList;
winStatus = ServiceList.Open( fCreatedNewServiceList );
if ( ERROR_SUCCESS == winStatus )
{
CLicRegLicenseService FilePrintService( FILEPRINT_SERVICE_REG_KEY );
winStatus = FilePrintService.Open( NULL, TRUE );
if ( ERROR_SUCCESS == winStatus )
{
LICENSE_MODE lm;
lm = fLicensePerServer ? LICMODE_PERSERVER : LICMODE_PERSEAT;
winStatus = FilePrintService.SetMode( lm );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetUserLimit( fLicensePerServer ? cPerServerLicenses : 0 );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetChangeFlag( fLicensePerServer );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetFamilyDisplayName( FILEPRINT_SERVICE_FAMILY_DISPLAY_NAME );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = FilePrintService.SetDisplayName( FILEPRINT_SERVICE_DISPLAY_NAME );
}
}
}
}
}
}
return winStatus;
}
static
DWORD
LicenseSetupWriteKeyLicenseService( BOOL fWriteParametersKey )
//
// Create registry values:
//
// HKEY_LOCAL_MACHINE
// \System
// \CurrentControlSet
// \Services
// \LicenseService
// \FilePrint
// \KSecDD
// \MSAfpSrv
// \SMBServer
// \TCP/IP Print Server
// \Parameters
// UseEnterprise : REG_DWORD : 0
// ReplicationType : REG_DWORD : 0
// ReplicationTime : REG_DWORD : 24 * 60 * 60
// EnterpriseServer : REG_SZ : ""
//
{
DWORD winStatus;
HKEY hKeyLicenseService;
DWORD dwKeyCreateDisposition;
// create LicenseInfo key
winStatus = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
LICENSE_SERVICE_REG_KEY,
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKeyLicenseService,
&dwKeyCreateDisposition );
if ( ERROR_SUCCESS == winStatus )
{
HKEY hKeyFilePrint;
// create FilePrint key
winStatus = RegCreateKeyEx( hKeyLicenseService,
TEXT( "FilePrint" ),
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKeyFilePrint,
&dwKeyCreateDisposition );
if ( ERROR_SUCCESS == winStatus )
{
const LPCTSTR apszFilePrintSubkeys[] =
{
TEXT( "KSecDD" ),
TEXT( "MSAfpSrv" ),
TEXT( "SMBServer" ),
TEXT( "TCP/IP Print Server" ),
NULL
};
HKEY hKeyFilePrintSubkey;
DWORD iSubkey;
for ( iSubkey = 0; NULL != apszFilePrintSubkeys[ iSubkey ]; iSubkey++ )
{
winStatus = RegCreateKeyEx( hKeyFilePrint,
apszFilePrintSubkeys[ iSubkey ],
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKeyFilePrintSubkey,
&dwKeyCreateDisposition );
if ( ERROR_SUCCESS == winStatus )
{
RegCloseKey( hKeyFilePrintSubkey );
}
else
{
break;
}
}
RegCloseKey( hKeyFilePrint );
}
RegCloseKey( hKeyLicenseService );
}
//
// Only write the Parameters key if the service was just created. That is,
// this is not an upgrade
//
if ( fWriteParametersKey && (ERROR_SUCCESS == winStatus) )
{
HKEY hKeyParameters;
// create Parameters key
winStatus = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
szLicenseKey, // const
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKeyParameters,
&dwKeyCreateDisposition );
if ( ERROR_SUCCESS == winStatus )
{
// create LicenseService\Parameters values
winStatus = RegSetValueEx( hKeyParameters,
szUseEnterprise, // const
0,
REG_DWORD,
(CONST BYTE *) &dwUseEnterprise, // const
sizeof( dwUseEnterprise ) );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = RegSetValueEx( hKeyParameters,
szReplicationType, // const
0,
REG_DWORD,
(CONST BYTE *) &dwReplicationType, // const
sizeof( dwReplicationType ) );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = RegSetValueEx( hKeyParameters,
szReplicationTime, // const
0,
REG_DWORD,
(CONST BYTE *) &dwReplicationTimeInSec, // const
sizeof( dwReplicationTimeInSec ) );
if ( ERROR_SUCCESS == winStatus )
{
LPCTSTR pszEnterpriseServer = TEXT( "" );
winStatus = RegSetValueEx( hKeyParameters,
szEnterpriseServer, // const
0,
REG_SZ,
(CONST BYTE *) pszEnterpriseServer,
( 1 + lstrlen( pszEnterpriseServer ) ) * sizeof( *pszEnterpriseServer ) );
}
}
}
RegCloseKey( hKeyParameters );
}
}
return winStatus;
}
static
DWORD
LicenseSetupWriteKeyEventLog()
//
// Create registry values:
//
// HKEY_LOCAL_MACHINE
// \System
// \CurrentControlSet
// \Services
// \EventLog
// \Application
// \LicenseService
// EventMessageFile : REG_EXPAND_SZ : %SystemRoot%\System32\llsrpc.dll
// TypesSupported : REG_DWORD : 7
//
{
DWORD winStatus;
HKEY hKeyLicenseService;
DWORD dwKeyCreateDisposition;
// create LicenseService key
winStatus = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
TEXT( "System\\CurrentControlSet\\Services\\EventLog\\Application\\LicenseService" ),
0,
NULL,
0,
KEY_ALL_ACCESS,
NULL,
&hKeyLicenseService,
&dwKeyCreateDisposition );
if ( ERROR_SUCCESS == winStatus )
{
LPCTSTR pszEventMessageFile = TEXT( "%SystemRoot%\\System32\\llsrpc.dll" );
const DWORD dwTypesSupported = ( EVENTLOG_ERROR_TYPE
| EVENTLOG_WARNING_TYPE
| EVENTLOG_INFORMATION_TYPE );
winStatus = RegSetValueEx( hKeyLicenseService,
TEXT( "TypesSupported" ),
0,
REG_DWORD,
(CONST BYTE *) &dwTypesSupported,
sizeof( dwTypesSupported ) );
if ( ERROR_SUCCESS == winStatus )
{
winStatus = RegSetValueEx( hKeyLicenseService,
TEXT( "EventMessageFile" ),
0,
REG_SZ,
(CONST BYTE *) pszEventMessageFile,
( 1 + lstrlen( pszEventMessageFile ) ) * sizeof( *pszEventMessageFile ) );
}
RegCloseKey( hKeyLicenseService );
}
return winStatus;
}
static
DWORD
LicenseSetupWriteService( BOOL * fCreated )
//
// Create/modify service:
//
// lpServiceName = "LicenseService"
// lpDisplayName = "License Logging Service"
// dwServiceType = SERVICE_WIN32_OWN_PROCESS
// dwStartType = LanManServerInstalled ? SERVICE_AUTO_START : SERVICE_DISABLED
// dwErrorControl = SERVICE_ERROR_NORMAL
// lpBinaryPathName = "%SystemRoot%\\System32\\llssrv.exe"
// lpLoadOrderGroup = NULL
// lpdwTagId = NULL
// lpDependencies = NULL
// lpServiceStartName = NULL
// lpPassword = NULL
//
{
SC_HANDLE hSC;
DWORD winStatus;
*fCreated = FALSE;
hSC = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if ( NULL == hSC )
{
winStatus = GetLastError();
}
else
{
HKEY hKeyLanmanServerParameters;
DWORD dwStartType ;
SC_HANDLE hLicenseService = NULL;
TCHAR szServiceDisplayName[ 128 ] = TEXT( "License Logging" );
TCHAR szServiceDescription[256] = TEXT("");
TCHAR szServiceStartName [] = TEXT("NT AUTHORITY\\NetworkService");
TCHAR szServicePassword[]=TEXT("");
SERVICE_DESCRIPTION svcDescription;
QUERY_SERVICE_CONFIG* pConfig = NULL;
DWORD cbBytesNeeded = 0;
BOOL frt;
DWORD dwDesiredAccess = SERVICE_ALL_ACCESS;
// enable service iff LanmanServer was installed
winStatus = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT( "SYSTEM\\CurrentControlSet\\Services\\LanmanServer\\Parameters" ),
0,
KEY_READ,
&hKeyLanmanServerParameters );
if ( ERROR_SUCCESS == winStatus )
{
dwStartType = SERVICE_AUTO_START;
hLicenseService = OpenService( hSC, TEXT( "LicenseService"), dwDesiredAccess );
if( hLicenseService != NULL )
{
cbBytesNeeded = sizeof(QUERY_SERVICE_CONFIG) + 4096;
pConfig = (LPQUERY_SERVICE_CONFIG) LocalAlloc( LPTR, cbBytesNeeded );
if ( pConfig != NULL )
{
frt = ::QueryServiceConfig( hLicenseService,
pConfig,
cbBytesNeeded,
&cbBytesNeeded );
if ( frt )
{
dwStartType = pConfig->dwStartType;
}
LocalFree ( pConfig ) ;
}
CloseServiceHandle( hLicenseService );
}
RegCloseKey( hKeyLanmanServerParameters );
}
else
{
dwStartType = SERVICE_DISABLED;
}
LoadString( g_hinst,
IDS_SERVICE_DISPLAY_NAME,
szServiceDisplayName,
sizeof( szServiceDisplayName ) / sizeof( *szServiceDisplayName ) );
LoadString( g_hinst,
IDS_SERVICE_DESCRIPTION,
szServiceDescription,
sizeof( szServiceDescription ) / sizeof( *szServiceDescription ) );
svcDescription.lpDescription = szServiceDescription;
hLicenseService = CreateService( hSC,
TEXT( "LicenseService" ),
szServiceDisplayName,
// 14659: needed to call ChangeConfig2 later
SERVICE_CHANGE_CONFIG,
SERVICE_WIN32_OWN_PROCESS,
dwStartType,
SERVICE_ERROR_NORMAL,
TEXT( "%SystemRoot%\\System32\\llssrv.exe" ),
NULL,
NULL,
NULL,
szServiceStartName,
szServicePassword );
if ( NULL != hLicenseService )
{
// service successfully created
ChangeServiceConfig2( hLicenseService,
SERVICE_CONFIG_DESCRIPTION,
&svcDescription );
CloseServiceHandle( hLicenseService );
winStatus = ERROR_SUCCESS;
*fCreated = TRUE;
}
else
{
winStatus = GetLastError();
if ( ERROR_SERVICE_EXISTS == winStatus )
{
// service already exists; change configuration of existing service
hLicenseService = OpenService( hSC,
TEXT( "LicenseService" ),
SERVICE_CHANGE_CONFIG );
if ( NULL == hLicenseService )
{
winStatus = GetLastError();
}
else
{
SC_LOCK scLock;
BOOL ok;
scLock = LockServiceDatabase( hSC );
// continue even if we can't lock the database
ok = ChangeServiceConfig( hLicenseService,
SERVICE_WIN32_OWN_PROCESS,
dwStartType,
SERVICE_ERROR_NORMAL,
TEXT( "%SystemRoot%\\System32\\llssrv.exe" ),
NULL,
NULL,
NULL,
szServiceStartName,
szServicePassword,
szServiceDisplayName );
if ( !ok )
{
winStatus = GetLastError();
}
else
{
ChangeServiceConfig2( hLicenseService,
SERVICE_CONFIG_DESCRIPTION,
&svcDescription);
winStatus = ERROR_SUCCESS;
}
if ( NULL != scLock )
{
UnlockServiceDatabase( scLock );
}
CloseServiceHandle( hLicenseService );
}
}
}
CloseServiceHandle( hSC );
}
CreateDirectoryWithAccess();
CreateFileWithAccess();
return winStatus;
}
void CreateDirectoryWithAccess()
{
DWORD winStatus = 0;
TCHAR tchWinDirPath[MAX_PATH+1] = L"";
PACL pNewDacl = NULL;
PACL pOldDacl = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
TCHAR tchLLSDirPath[ MAX_PATH +1] = L"";
BOOL bFlag = FALSE;
PSID pSid = NULL;
EXPLICIT_ACCESS ExplicitEntries;
SID_IDENTIFIER_AUTHORITY ntSidAuthority = SECURITY_NT_AUTHORITY;
winStatus = GetSystemWindowsDirectory( tchWinDirPath , MAX_PATH+1);
if(winStatus == 0)
{
goto cleanup;
}
lstrcpy(tchLLSDirPath, tchWinDirPath);
lstrcat( tchLLSDirPath , L"\\system32\\lls" );
// Creating new EXPLICIT_ACCESS structure to set on the directory
ZeroMemory( &ExplicitEntries, sizeof(ExplicitEntries) );
bFlag = AllocateAndInitializeSid(
&ntSidAuthority,
1,
SECURITY_NETWORK_SERVICE_RID,0,
0, 0, 0, 0, 0, 0,
&pSid );
if ( !bFlag || (pSid == NULL) ) {
goto cleanup;
}
BuildTrusteeWithSid( &ExplicitEntries.Trustee, pSid );
ExplicitEntries.grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
ExplicitEntries.grfAccessMode = SET_ACCESS;
ExplicitEntries.grfAccessPermissions = FILE_ALL_ACCESS;
ExplicitEntries.Trustee.TrusteeForm = TRUSTEE_IS_SID;
ExplicitEntries.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
bFlag = CreateDirectory( tchLLSDirPath, NULL );
if ( !bFlag )
{
winStatus = GetLastError();
if (ERROR_ALREADY_EXISTS != winStatus)
{
goto cleanup;
}
}
if( GetNamedSecurityInfoW( tchLLSDirPath,
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION,
NULL, // psidOwner
NULL, // psidGroup
&pOldDacl, // pDacl
NULL, // pSacl
&pSD ) != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Set the Acl with the ExplicitEntry rights
//
if( SetEntriesInAcl( 1,
&ExplicitEntries,
pOldDacl,
&pNewDacl ) != ERROR_SUCCESS)
{
goto cleanup;
}
//
// SET security on the Directory
//
winStatus = SetNamedSecurityInfo(
tchLLSDirPath, // object name
SE_FILE_OBJECT , // object type
DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION , // type
NULL, // new owner SID
NULL, // new primary group SID
pNewDacl, // new DACL
NULL // new SACL
);
cleanup:
if(pSid)
{
LocalFree( pSid );
}
if(pSD)
{
LocalFree(pSD);
pSD = NULL;
}
if(pNewDacl)
{
LocalFree(pNewDacl);
pNewDacl = NULL;
}
}
void CreateFileWithAccess()
{
DWORD winStatus = 0;
TCHAR tchWinDirPath[MAX_PATH+1] = L"";
PACL pNewDacl = NULL;
PACL pOldDacl = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
TCHAR tchCPLFilePath[ MAX_PATH+1 ] = L"";
BOOL bFlag = FALSE;
PSID pSid = NULL;
EXPLICIT_ACCESS ExplicitEntries;
SID_IDENTIFIER_AUTHORITY ntSidAuthority = SECURITY_NT_AUTHORITY;
HANDLE hFile = NULL;
winStatus = GetSystemWindowsDirectory( tchWinDirPath , MAX_PATH+1);
if(winStatus == 0)
{
goto cleanup;
}
lstrcpy(tchCPLFilePath, tchWinDirPath);
lstrcat( tchCPLFilePath , L"\\system32\\cpl.cfg" );
// Creating new EXPLICIT_ACCESS structure to set on the file
ZeroMemory( &ExplicitEntries, sizeof(ExplicitEntries) );
bFlag = AllocateAndInitializeSid(
&ntSidAuthority,
1,
SECURITY_NETWORK_SERVICE_RID,0,
0, 0, 0, 0, 0, 0,
&pSid );
if ( !bFlag || (pSid == NULL) ) {
goto cleanup;
}
BuildTrusteeWithSid( &ExplicitEntries.Trustee, pSid );
ExplicitEntries.grfAccessMode = SET_ACCESS;
ExplicitEntries.grfAccessPermissions = FILE_ALL_ACCESS;
ExplicitEntries.Trustee.TrusteeForm = TRUSTEE_IS_SID;
ExplicitEntries.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
hFile = CreateFile(tchCPLFilePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
0,
NULL);
if(hFile == NULL)
{
winStatus = GetLastError();
if (winStatus != ERROR_ALREADY_EXISTS) {
goto cleanup ;
}
}
if( GetNamedSecurityInfoW( tchCPLFilePath,
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION,
NULL, // psidOwner
NULL, // psidGroup
&pOldDacl, // pDacl
NULL, // pSacl
&pSD ) != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Set the Acl with the ExplicitEntry rights
//
if( SetEntriesInAcl( 1,
&ExplicitEntries,
pOldDacl,
&pNewDacl ) != ERROR_SUCCESS)
{
goto cleanup;
}
//
// SET security on the File
//
winStatus = SetNamedSecurityInfo(
tchCPLFilePath, // object name
SE_FILE_OBJECT , // object type
DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION , // type
NULL, // new owner SID
NULL, // new primary group SID
pNewDacl, // new DACL
NULL // new SACL
);
cleanup:
if(hFile)
{
CloseHandle(hFile);
}
if(pSid)
{
LocalFree( pSid );
}
if(pSD)
{
LocalFree(pSD);
pSD = NULL;
}
if(pNewDacl)
{
LocalFree(pNewDacl);
pNewDacl = NULL;
}
}
static
int
MessageBoxFromStringID(
HWND hwndParent,
UINT uTextID,
UINT uCaptionID,
UINT uType )
//
// Same as MessageBox(), except Text and Caption are string resources
// instead of string pointers.
//
{
int nButton;
TCHAR szText[ 1024 ];
TCHAR szCaption[ 64 ];
LoadString( g_hinst, uTextID, szText, sizeof( szText ) / sizeof( *szText ) );
LoadString( g_hinst, uCaptionID, szCaption, sizeof( szCaption ) / sizeof( *szCaption ) );
nButton = MessageBox( hwndParent, szText, szCaption, uType );
return nButton;
}
Reference in a new issue Copy permalink