/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
dbsamtst.c
Abstract:
LSA Database - SAM Database load testing code
When enabled, this code provides a mechanism for stress loading of the
SAM database with a large number of accounts. The load executes in the
context of lsass.exe, similar to how it does in replication.
Author:
Scott Birrell (ScottBi) January 10, 1992
Environment:
Revision History:
--*/
#include "lsasrvp.h"
#include <lsaisrv.h>
#include "dbp.h"
//
// Uncomment the define LSA_SAM_ACCOUNTS_DOMAIN_TEST to enable the
// code needed for the ctsamdb test program. Recompile dbsamtst.c,
// dbpolicy.c. rebuild lsasrv.dll and nmake UMTYPE=console UMTEST=ctsamdb.
//
#ifdef LSA_SAM_ACCOUNTS_DOMAIN_TEST
//
// Global data needed by test
//
//
// Random Unicode text Buffer (gets updated pseudo-randomly during run)
//
#define LSAP_DB_TEST_TEXT_BUFF_CHAR_LENGTH ((ULONG) 1024)
#define LSAP_DB_TEST_TEXT_BUFF_BYTE_LENGTH \
(LSAP_DB_TEST_TEXT_BUFF_CHAR_LENGTH * sizeof (WCHAR))
static PWSTR TextBuffer = L"ABCDEFGHIJKLMNOPQRSTUVWXYZAABBCC"
L"DDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSS"
L"TTUUVVWWXXYYZZZYXWVUTSRQPONMLKJI"
L"HGFEDCBAMEJHCKZXHDKCXJHCKXSKLCJJ"
L"QKXJHDHNSLCJIFUENSGXCJCVKLSJKSHD"
L"QXKXJHDGHASOESDGPMSDVJKSDNJCKACJ"
L"AOJSDVJKJASDHABJKACSBNVAJKAJSKDV"
L"AJLSBSDJBVAJKLQWDQBVAKLJSCVAKLDD"
L"OJWQEFBNQGOTQJWDBVBJOQWDBXQPJJPB"
L"QWERTYUIOPASDFGHJKLZXCVBNMQUFIEJ"
L"ARWFUITYBNOMVJGBLJHKGJKGKGTJHKHS"
L"AOPDEBLFPYVQRUCVKJGRKSDBKGKWPOID"
L"MBCZLADJGFDOYEJHLSDYQWHLSOQLFHBF"
L"MCNXBZLGHKFDKDHSAQTWYEUTODMKCVJW"
L"QOPKIJUNYBTYVTCRCXEXECDWZQGGICRT"
L"ZWRFXCERYHVFYJNGHJNMBGTYVFJNMJJK";
//
// Random Unicode text Buffer backup (used for reset)
//
static PWSTR TextBuffBak = L"ABCDEFGHIJKLMNOPQRSTUVWXYZAABBCC"
L"DDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSS"
L"TTUUVVWWXXYYZZZYXWVUTSRQPONMLKJI"
L"HGFEDCBAMEJHCKZXHDKCXJHCKXSKLCJJ"
L"QKXJHDHNSLCJIFUENSGXCJCVKLSJKSHD"
L"QXKXJHDGHASOESDGPMSDVJKSDNJCKACJ"
L"AOJSDVJKJASDHABJKACSBNVAJKAJSKDV"
L"AJLSBSDJBVAJKLQWDQBVAKLJSCVAKLDD"
L"OJWQEFBNQGOTQJWDBVBJOQWDBXQPJJPB"
L"QWERTYUIOPASDFGHJKLZXCVBNMQUFIEJ"
L"ARWFUITYBNOMVJGBLJHKGJKGKGTJHKHS"
L"AOPDEBLFPYVQRUCVKJGRKSDBKGKWPOID"
L"MBCZLADJGFDOYEJHLSDYQWHLSOQLFHBF"
L"MCNXBZLGHKFDKDHSAQTWYEUTODMKCVJW"
L"QOPKIJUNYBTYVTCRCXEXECDWZQGGICRT"
L"ZWRFXCERYHVFYJNGHJNMBGTYVFJNMJJK";
static ULONG Array0Index = 0,
Array1Index = 0,
Array2Index = 0,
Array3Index = 0,
Array4Index = 0,
Array5Index = 0;
static ULONG Array0[] = { 0, 44, 88 };
static ULONG Array1[] = { 87,2,45,48,68};
static ULONG Array2[] = { 23,1,43,37,4,16,8 };
static ULONG Array3[] = { 64,5,17,29,18,17,22,56,19,20,6 };
static ULONG Array4[] = { 7,11,97,88,8,5,24,0,99,51,33,20,80 };
static ULONG Array5[] = { 53,56,3,27,29,98,35,47,53,92,89,4,66,34,1,99,3 };
NTSTATUS
LsapDbTestLoadSamAccountsDomain(
IN PUNICODE_STRING NumberOfAccounts
);
NTSTATUS
LsapDbTestLoadSamAccountsDomainInitialize(
IN OUT PUSER_ALL_INFORMATION UserInformation
);
NTSTATUS
LsapDbTestCreateNextAccountInfo(
IN OUT PUSER_ALL_INFORMATION UserInformation
);
NTSTATUS
LsapDbTestGenUnicodeString(
OUT PUNICODE_STRING OutputString,
IN ULONG MinimumLength,
IN ULONG MaximumLength
);
PWSTR
LsapDbTestGenRandomStringPointer(
IN ULONG MinLengthToLeaveAtEnd
);
ULONG
LsapDbTestGenRandomNumber(
IN ULONG MinimumValue,
IN ULONG MaximumValue
);
NTSTATUS
LsapDbTestLoadSamAccountsDomain(
IN PUNICODE_STRING NumberOfAccounts
)
/*++
Routine Description:
This function creates a number of users in the local SAM Accounts Domain,
or deletes previously created users in the domain.
Arguments:
AccountCount - Specifies the number of accounts to be created. If a negative
number is specified, the accounts are deleted.
Return Values:
NTSTATUS - Standard Nt Result Code
--*/
{
NTSTATUS Status, EnumerateStatus;
LONG AccountNumber = 0;
LONG AccountCount = 0;
LONG CollisionCount = 0;
LONG ExistingAccountCount = 0;
LONG DeletedUserCount = 0;
ANSI_STRING NumberOfAccountsAnsi;
PLSAPR_POLICY_ACCOUNT_DOM_INFO PolicyAccountDomainInfo = NULL;
LSA_TRUST_INFORMATION TrustInformation;
SAMPR_HANDLE LocalSamServerHandle = NULL;
USER_ALL_INFORMATION UserInformation;
SAMPR_HANDLE UserHandle = NULL;
SAMPR_HANDLE LocalSamDomainHandle = NULL;
ULONG InitialRelativeId, RelativeId;
ULONG CountReturned;
SAM_ENUMERATE_HANDLE EnumerationContext = 0;
PSAMPR_ENUMERATION_BUFFER RidEnumerationBuffer = NULL;
ULONG NextAccount;
ULONG ConflictingAccountRid;
LARGE_INTEGER StartTime, TimeAfterThis100Users, TimeAfterPrevious100Users;
LARGE_INTEGER TimeForThis100Users, TimeForThis100UsersInMs, TotalTime, TenThousand;
//
// Open the local SAM Accounts Domain
//
// The Sid and Name of the Account Domain are both configurable, and
// we need to obtain them from the Policy Object. Now obtain the
// Account Domain Sid and Name by querying the appropriate
// Policy Information Class.
//
Status = LsarQueryInformationPolicy(
LsapPolicyHandle,
PolicyAccountDomainInformation,
(PLSAPR_POLICY_INFORMATION *) &PolicyAccountDomainInfo
);
if (!NT_SUCCESS(Status)) {
KdPrint(("LsarQueryInformationPolicy failed 0x%lx\n", Status));
goto TestLoadSamAccountsDomainError;
}
//
// Set up the Trust Information structure for the Account Domain.
//
TrustInformation.Sid = PolicyAccountDomainInfo->DomainSid;
RtlCopyMemory(
&TrustInformation.Name,
&PolicyAccountDomainInfo->DomainName,
sizeof (UNICODE_STRING)
);
//
// Connect to the Local Sam. The LSA server is a trusted client, so we
// call the internal version of the SamConnect routine.
//
Status = SamIConnect( NULL, &LocalSamServerHandle, 0, TRUE );
if (!NT_SUCCESS(Status)) {
KdPrint(("SamIConnect failed 0x%lx\n", Status));
goto TestLoadSamAccountsDomainError;
}
//
// Open the Account Domain.
//
Status = SamrOpenDomain(
LocalSamServerHandle,
DOMAIN_LOOKUP,
TrustInformation.Sid,
&LocalSamDomainHandle
);
if (!NT_SUCCESS(Status)) {
KdPrint(("SamrOpenDomain failed 0x%lx\n", Status));
goto TestLoadSamAccountsDomainError;
}
//
// Now convert the count of accounts from unicode.
//
Status = RtlUnicodeStringToAnsiString(
&NumberOfAccountsAnsi,
NumberOfAccounts,
TRUE
);
if (!NT_SUCCESS(Status)) {
KdPrint(("RtlUnicodeStringToAnsiString failed 0x%lx\n", Status));
goto TestLoadSamAccountsDomainError;
}
AccountCount = (LONG) atoi(NumberOfAccountsAnsi.Buffer);
//
// Tke initial relative id is used by both the create and delete
// account branches so initialize it here.
//
InitialRelativeId = (ULONG) 0x00001000L;
//
// If the number of accounts is > 0, add the specified number of
// accounts to the SAM account domain. If the number of accounts is
// < 0, delete all accounts from the SAM account s domain.
//
if (AccountCount > 0) {
//
// Initialize the constant fields in the UserInformation structure
//
Status = LsapDbTestLoadSamAccountsDomainInitialize(&UserInformation);
if (!NT_SUCCESS(Status)) {
goto TestLoadSamAccountsDomainError;
}
KdPrint(("Sam Account Database Load Begins\n"));
Status = NtQuerySystemTime( &StartTime );
if (!NT_SUCCESS(Status)) {
return(Status);
}
TimeAfterPrevious100Users = StartTime;
//
// Conversion factor for converting 100ns ticks to milliseconds
//
TenThousand = RtlConvertUlongToLargeInteger((ULONG) 10000);
for( AccountNumber = 0; AccountNumber < AccountCount; AccountNumber++) {
//
// Generate Information for this Account
//
Status = LsapDbTestCreateNextAccountInfo(&UserInformation);
if (!NT_SUCCESS(Status)) {
break;
}
RelativeId = InitialRelativeId + (ULONG) AccountNumber;
//
// Create the account
//
ConflictingAccountRid = (ULONG) 0;
Status = SamICreateAccountByRid(
LocalSamDomainHandle,
SamObjectUser,
RelativeId,
(PRPC_UNICODE_STRING) &UserInformation.UserName,
USER_ALL_ACCESS,
&UserHandle,
&ConflictingAccountRid
);
if (!NT_SUCCESS(Status)) {
if ((Status == STATUS_USER_EXISTS) || (Status == STATUS_OBJECT_TYPE_MISMATCH)) {
CollisionCount++;
AccountNumber--;
if ((CollisionCount%100)==0) {
KdPrint(("."));
}
continue;
}
KdPrint(("SamrCreateAccountByRid failed 0x%lx\n", Status));
break;
}
//
// If an account already existed with the given Rid and had
// the same account type and name, it will have been opened.
// Record the number of occurrences of this.
//
if (ConflictingAccountRid == RelativeId) {
ExistingAccountCount++;
}
//
// Set the information for the account
//
UserInformation.UserId = RelativeId;
Status = SamrSetInformationUser(
UserHandle,
UserAllInformation,
(PSAMPR_USER_INFO_BUFFER) &UserInformation
);
if (!NT_SUCCESS(Status)) {
KdPrint(("SamrSetInformationUser failed 0x%lx\n", Status));
break;
}
Status = SamrCloseHandle( &UserHandle );
if ((AccountNumber > 0) && ((AccountNumber % 100) == 0)) {
Status = NtQuerySystemTime( &TimeAfterThis100Users );
if (!NT_SUCCESS(Status)) {
break;
}
TimeForThis100Users.QuadPart = TimeAfterThis100Users.QuadPart -
TimeAfterPrevious100Users.QuadPart;
TimeForThis100UsersInMs = TimeForThis100Users.QuadPart /
TenThousand.QuadPart;
TotalTime = TimeAfterThis100Users.QuadPart -
StartTime.QuadPart;
KdPrint(("%d Accounts Created\n", AccountNumber));
KdPrint(("Last 100 users took %d millisecs to create\n", TimeForThis100UsersInMs.LowPart));
if (ExistingAccountCount > 0) {
KdPrint(("%d Attempts to create non-conflicting existing users\n\n", ExistingAccountCount));
}
if (CollisionCount > 0) {
KdPrint(("%d Creation conflicts with existing users\n", CollisionCount));
}
TimeAfterPrevious100Users = TimeAfterThis100Users;
}
}
KdPrint(("%d Accounts Created\n", AccountNumber));
KdPrint(("%d existing accounts opened\n", ExistingAccountCount));
KdPrint(("%d Rid/Name/Type conflicts with existing accounts\n", CollisionCount));
KdPrint(("\nSam Account Database Load Ends\n"));
} else if (AccountCount < 0) {
//
// Delete the accounts
//
KdPrint(("Deleting user accounts with Rid >= 4096 in the local SAM Accounts Domain\n"));
EnumerateStatus = STATUS_MORE_ENTRIES;
while(EnumerateStatus == STATUS_MORE_ENTRIES) {
RidEnumerationBuffer = NULL;
Status = SamrEnumerateUsersInDomain(
LocalSamDomainHandle,
&EnumerationContext,
USER_NORMAL_ACCOUNT,
(PSAMPR_ENUMERATION_BUFFER *) &RidEnumerationBuffer,
4096,
&CountReturned
);
EnumerateStatus = Status;
if (!NT_SUCCESS(Status)) {
KdPrint(("SamrEnumerateUsersInDomain failed 0x%lx\n", Status));
break;
}
if (CountReturned == 0) {
break;
}
for (NextAccount = 0; NextAccount < CountReturned; NextAccount++) {
RelativeId = RidEnumerationBuffer->Buffer[ NextAccount ].RelativeId;
//
// Skip this account if it's not one of ours. This is not
// a rigorous check, but works.
//
if (RelativeId < InitialRelativeId) {
continue;
}
Status = SamrOpenUser(
LocalSamDomainHandle,
DELETE,
RelativeId,
&UserHandle
);
if (!NT_SUCCESS(Status)) {
KdPrint(("SamrOpenUser failed 0x%lx\n", Status));
break;
}
Status = SamrDeleteUser( &UserHandle );
if (!NT_SUCCESS(Status)) {
if (Status != STATUS_SPECIAL_ACCOUNT) {
KdPrint(("SamrDeleteUser failed 0x%lx\n", Status));
break;
}
Status = SamrCloseHandle(&UserHandle);
if (!NT_SUCCESS(Status)) {
KdPrint(("SamrCloseHandle failed 0x%lx\n", Status));
break;
}
}
DeletedUserCount++;
}
if (!NT_SUCCESS(Status)) {
break;
}
}
if (NT_SUCCESS(Status)) {
KdPrint(("%d user accounts deleted\n", DeletedUserCount));
KdPrint(("Deletion of user accounts ends\n"));
}
}
TestLoadSamAccountsDomainFinish:
return(Status);
TestLoadSamAccountsDomainError:
goto TestLoadSamAccountsDomainFinish;
}
NTSTATUS
LsapDbTestLoadSamAccountsDomainInitialize(
IN OUT PUSER_ALL_INFORMATION UserInformation
)
/*++
Routine Description:
This function initializes the constant values required by the
SAM Accounts Domain load/update tests. These values include
static global data and fixed values within a USER_ALL_INFORMATION
structure used for creating/updating accounts.
Arguments:
UserInformation - Points to USER_ALL_INFORMATION structure.
Return Values:
NTSTATUS - Standard Nt Result Code
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG Index;
static UCHAR LogonHours[SAM_HOURS_PER_WEEK / 8];
//
// Restore the Unicode Text Buffer used for generating random
// Unicode Strings to its original contents.
//
RtlCopyMemory( TextBuffer, TextBuffBak, LSAP_DB_TEST_TEXT_BUFF_CHAR_LENGTH );
//
// Reset the random number generator indices
//
Array0Index = 0;
Array1Index = 0;
Array2Index = 0;
Array3Index = 0;
Array4Index = 0;
Array5Index = 0;
//
// Initialize Logon Hours data
//
for( Index = 0; Index < (SAM_HOURS_PER_WEEK / 8); Index++) {
LogonHours[Index] = (UCHAR) 0xff;
}
//
// Initialize constaint values in User Information structure
//
UserInformation->LogonCount = 0;
UserInformation->LogonHours.UnitsPerWeek = SAM_HOURS_PER_WEEK;
UserInformation->LogonHours.LogonHours = LogonHours;
UserInformation->BadPasswordCount = 1;
UserInformation->LogonCount = 1;
UserInformation->UserAccountControl = USER_NORMAL_ACCOUNT;
UserInformation->CountryCode = 1;
UserInformation->CodePage = 850;
UserInformation->NtPasswordPresent = FALSE;
UserInformation->LmPasswordPresent = FALSE;
UserInformation->PasswordExpired = FALSE;
UserInformation->SecurityDescriptor.SecurityDescriptor = NULL;
UserInformation->SecurityDescriptor.Length = 0;
UserInformation->WhichFields =
(
USER_ALL_USERNAME |
USER_ALL_FULLNAME |
USER_ALL_ADMINCOMMENT |
USER_ALL_USERCOMMENT |
USER_ALL_HOMEDIRECTORY |
USER_ALL_HOMEDIRECTORYDRIVE |
USER_ALL_SCRIPTPATH |
USER_ALL_PROFILEPATH |
USER_ALL_LOGONHOURS |
USER_ALL_USERACCOUNTCONTROL
);
return(Status);
}
NTSTATUS
LsapDbTestCreateNextAccountInfo(
IN OUT PUSER_ALL_INFORMATION UserInformation
)
/*++
Routine Description:
This function generates the user information for the next user.
Arguments:
UserInformation - Pointer to User Information structure
Return Values:
NTSTATUS - Standard Nt Result Code
--*/
{
#define LSAP_TEST_MIN_USERNAME_LENGTH ((ULONG) 0x00000005L)
#define LSAP_TEST_MAX_USERNAME_LENGTH ((ULONG) 0x0000000cL)
#define LSAP_TEST_MIN_FULLNAME_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_FULLNAME_LENGTH ((ULONG) 0x00000030L)
#define LSAP_TEST_MIN_HOMEDIR_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_HOMEDIR_LENGTH ((ULONG) 0x00000030L)
#define LSAP_TEST_MIN_SCRIPTPATH_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_SCRIPTPATH_LENGTH ((ULONG) 0x00000100L)
#define LSAP_TEST_MIN_PROFPATH_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_PROFPATH_LENGTH ((ULONG) 0x00000100L)
#define LSAP_TEST_MIN_DRIVE_LENGTH ((ULONG) 0x00000001L)
#define LSAP_TEST_MAX_DRIVE_LENGTH ((ULONG) 0x00000001L)
#define LSAP_TEST_MIN_ADMCMT_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_ADMCMT_LENGTH ((ULONG) 0x00000100L)
#define LSAP_TEST_MIN_WKSTA_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_WKSTA_LENGTH ((ULONG) 0x00000040L)
#define LSAP_TEST_MIN_USER_COMMENT_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_USER_COMMENT_LENGTH ((ULONG) 0x00000040L)
#define LSAP_TEST_MIN_PARAMS_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_PARAMS_LENGTH ((ULONG) 0x00000040L)
#define LSAP_TEST_MIN_PRIVDATA_LENGTH ((ULONG) 0x00000003L)
#define LSAP_TEST_MAX_PRIVDATA_LENGTH ((ULONG) 0x00000040L)
NTSTATUS Status;
Status = LsapDbTestGenUnicodeString(
&UserInformation->UserName,
LSAP_TEST_MIN_USERNAME_LENGTH,
LSAP_TEST_MAX_USERNAME_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->FullName,
LSAP_TEST_MIN_FULLNAME_LENGTH,
LSAP_TEST_MAX_FULLNAME_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->HomeDirectoryDrive,
LSAP_TEST_MIN_DRIVE_LENGTH,
LSAP_TEST_MAX_DRIVE_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->HomeDirectory,
LSAP_TEST_MIN_HOMEDIR_LENGTH,
LSAP_TEST_MAX_HOMEDIR_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->ScriptPath,
LSAP_TEST_MIN_SCRIPTPATH_LENGTH,
LSAP_TEST_MAX_SCRIPTPATH_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->ProfilePath,
LSAP_TEST_MIN_PROFPATH_LENGTH,
LSAP_TEST_MAX_PROFPATH_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->AdminComment,
LSAP_TEST_MIN_ADMCMT_LENGTH,
LSAP_TEST_MAX_ADMCMT_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->WorkStations,
LSAP_TEST_MIN_WKSTA_LENGTH,
LSAP_TEST_MAX_WKSTA_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->UserComment,
LSAP_TEST_MIN_USER_COMMENT_LENGTH,
LSAP_TEST_MAX_USER_COMMENT_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
&UserInformation->Parameters,
LSAP_TEST_MIN_PARAMS_LENGTH,
LSAP_TEST_MAX_PARAMS_LENGTH
);
if (!NT_SUCCESS(Status)) {
return(Status);
}
Status = LsapDbTestGenUnicodeString(
(PUNICODE_STRING) &UserInformation->PrivateData,
LSAP_TEST_MIN_PRIVDATA_LENGTH,
LSAP_TEST_MAX_PRIVDATA_LENGTH
);
return(Status);
}
NTSTATUS
LsapDbTestGenUnicodeString(
OUT PUNICODE_STRING OutputString,
IN ULONG MinimumLength,
IN ULONG MaximumLength
)
/*++
Routine Description:
This function generates a pseudo-random Unicode String whose length
lies within the indicated bounds.
Arguments:
OutputString - Points to output UNICODE_STRING structure to be
initialized.
MinimumLength - Minimum length required in wide characters.
MaximumLength - Maximum length required in wide characters.
Return Values:
NTSTATUS - Standard Nt Result Code
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
OutputString->Length = (USHORT) (sizeof(WCHAR) * LsapDbTestGenRandomNumber(
MinimumLength,
MaximumLength
));
OutputString->Buffer = LsapDbTestGenRandomStringPointer(
(OutputString->Length / 2)
);
OutputString->MaximumLength = OutputString->Length;
return(Status);
}
PWSTR
LsapDbTestGenRandomStringPointer(
IN ULONG MinLengthToLeaveAtEnd
)
/*++
Routine Description:
This function returns a random pointer to a location within a global
block of text.
Arguments:
MinLengthToLeaveAtEnd - Specifies the minimum length of the string
in Wide Chars from the returned pointer to the end of the global buffer.
Return Values:
PUCHAR - Receives a pointer referencing a character within the block
of text.
--*/
{
WCHAR Temp;
ULONG Offset = LsapDbTestGenRandomNumber(
0,
(ULONG) 512 - MinLengthToLeaveAtEnd
);
ULONG Offset1 = LsapDbTestGenRandomNumber(
0,
(ULONG) 512 - 1
);
ULONG Offset2 = LsapDbTestGenRandomNumber(
0,
(ULONG) 512 - 1
);
ULONG Offset3 = LsapDbTestGenRandomNumber(
0,
(ULONG) 512 - 1
);
ULONG Offset4 = LsapDbTestGenRandomNumber(
0,
(ULONG) 512 - 1
);
//
// Randomly alter the 2nd to 6th characters of the selected string.
//
Temp = TextBuffer[Offset + 1];
TextBuffer[Offset + 1] = TextBuffer[Offset1];
TextBuffer[Offset1] = Temp;
if ((Offset > 0) && (Offset < (ULONG) (512 - 2))) {
Temp = TextBuffer[Offset + 2];
TextBuffer[Offset + 2] = TextBuffer[Offset2];
TextBuffer[Offset2] = Temp;
}
if ((Offset > 0) && (Offset < (ULONG) (512 - 3))) {
Temp = TextBuffer[Offset + 3];
TextBuffer[Offset + 3] = TextBuffer[Offset3];
TextBuffer[Offset3] = Temp;
}
if ((Offset > 0) && (Offset < (ULONG) (512 - 4))) {
Temp = TextBuffer[Offset + 4];
TextBuffer[Offset + 4] = TextBuffer[Offset4];
TextBuffer[Offset4] = Temp;
}
return(&TextBuffer[Offset]);
}
ULONG
LsapDbTestGenRandomNumber(
IN ULONG MinimumValue,
IN ULONG MaximumValue
)
/*++
Routine Description:
This function generates a pseudo-random unsigned integer lying between
two values.
Arguments:
MinimumValue - The minimum value of the random number
MaximumValue - The maximum value of the random number
--*/
{
ULONG NextValue, NextValue1, NextValue2;
ULONG MaxPossValue = 88 + 87 + 43 + 64 + 99 + 99;
Array0Index++;
if (Array0Index == sizeof(Array0) / sizeof(ULONG)) {
Array0Index = 0;
}
Array1Index++;
if (Array1Index == sizeof(Array1) / sizeof(ULONG)) {
Array1Index = 0;
}
Array2Index++;
if (Array2Index == sizeof(Array2) / sizeof(ULONG)) {
Array2Index = 0;
}
Array3Index++;
if (Array3Index == sizeof(Array3) / sizeof(ULONG)) {
Array3Index = 0;
}
Array4Index++;
if (Array4Index == sizeof(Array4) / sizeof(ULONG)) {
Array4Index = 0;
}
Array5Index++;
if (Array5Index == sizeof(Array5) / sizeof(ULONG)) {
Array5Index = 0;
}
NextValue1 = Array0[Array0Index] +
Array1[Array1Index] +
Array2[Array2Index] +
Array3[Array3Index] +
Array4[Array4Index] +
Array5[Array5Index];
Array0Index++;
if (Array0Index == sizeof(Array0) / sizeof(ULONG)) {
Array0Index = 0;
}
Array1Index++;
if (Array1Index == sizeof(Array1) / sizeof(ULONG)) {
Array1Index = 0;
}
Array2Index++;
if (Array2Index == sizeof(Array2) / sizeof(ULONG)) {
Array2Index = 0;
}
Array3Index++;
if (Array3Index == sizeof(Array3) / sizeof(ULONG)) {
Array3Index = 0;
}
Array4Index++;
if (Array4Index == sizeof(Array4) / sizeof(ULONG)) {
Array4Index = 0;
}
Array5Index++;
if (Array5Index == sizeof(Array5) / sizeof(ULONG)) {
Array5Index = 0;
}
NextValue2 = Array0[Array0Index] +
Array1[Array1Index] +
Array2[Array2Index] +
Array3[Array3Index] +
Array4[Array4Index] +
Array5[Array5Index];
if (NextValue2 > NextValue1) {
NextValue = NextValue2 - NextValue1;
} else {
NextValue = NextValue1 - NextValue2;
}
NextValue = MinimumValue +
(MaximumValue - MinimumValue) * NextValue / MaxPossValue;
return(NextValue);
}
#endif // LSA_SAM_ACCOUNTS_DOMAIN_TEST