able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/oleutest/accctrl/client/oactestc.cxx

2162 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************
File: actestc.cxx
Description: Client side of the DCOM IAccessControl test program.
****************************************************************************/
#include <windows.h>
#include <ole2.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <accctrl.h>
#include "oactest.h"
#include <oleext.h>
#include <rpcdce.h>
/* Internal program parameters */
#define BIG_BUFFER 2048
#define LINE_BUFF_SIZE 200
#define MAX_TOKENS_NUM 20
#define STR_LEN 100
// Define some bogus access masks so that we can verify the
// the validation mechanism of DCOM IAccessControl
#define BOGUS_ACCESS_RIGHT1 (COM_RIGHTS_EXECUTE*2)
#define BOGUS_ACCESS_RIGHT2 (COM_RIGHTS_EXECUTE*4)
#define BOGUS_ACCESS_RIGHT3 (COM_RIGHTS_EXECUTE*8)
#define BOGUS_ACCESS_RIGHT4 (COM_RIGHTS_EXECUTE*16)
// The following structure encapsulates all kinds of information that
// can be associated with a trustee.
typedef struct tagTRUSTEE_RECORD
{
DWORD grfAccessPermissions;
ACCESS_MODE grfAccessMode;
DWORD grfInheritance;
PTRUSTEE_W pMultipleTrustee;
MULTIPLE_TRUSTEE_OPERATION MultipleTrusteeOperation;
TRUSTEE_FORM TrusteeForm;
TRUSTEE_TYPE TrusteeType;
LPWSTR pwszTrusteeName;
PISID pSID;
} TRUSTEE_RECORD;
/* Global variables */
char pszUserName[STR_LEN]; // User Name
char pszBasePath[STR_LEN];
char pszResource[STR_LEN]; // Resource location
EXPLICIT_ACCESS_W g_pLocalExplicitAccessList[100];
ULONG g_ulNumOfLocalExplicitAccesses = 0;
ACCESS_REQUEST_W g_pLocalAccessRequestList[100];
ULONG g_ulNumOfLocalAccessRequests = 0;
PEXPLICIT_ACCESS_W g_pReturnedExplicitAccessList = NULL;
ULONG g_ulNumOfExplicitAccessesReturned = 0;
TRUSTEE_W g_pLocalTrusteeList[100];
ULONG g_ulNumOfLocalTrustees = 0;
TRUSTEE_RECORD g_LocalTrusteeRecord;
IAccessControlTest *g_pIAccessControlTest;
IUnknown *g_pIUnknown;
const CLSID CLSID_COAccessControlTest
= {0x20692b00,0xe710,0x11cf,{0xaf,0x0b,0x00,0xaa,0x00,0x44,0xfb,0x89}};
/* Internal function prototyoes */
void Tokenize(char *, char *[], short *);
void stringtolower(char *);
PISID GetSIDForTrustee(LPWSTR);
void AddTrusteeToExplicitAccessList(TRUSTEE_RECORD *, PEXPLICIT_ACCESS_W, ULONG *);
void DeleteTrusteeFromExplicitAccessList(ULONG, PEXPLICIT_ACCESS_W, ULONG *);
void AddTrusteeToAccessRequestList(TRUSTEE_RECORD *, PACCESS_REQUEST_W, ULONG *);
void DeleteTrusteeFromAccessRequestList(ULONG, PACCESS_REQUEST_W, ULONG *);
void MapTrusteeRecordToTrustee(TRUSTEE_RECORD *, TRUSTEE_W *);
void AddTrusteeToTrusteeList(TRUSTEE_RECORD *, TRUSTEE_W *, ULONG *);
void DeleteTrusteeFromTrusteeList(ULONG, TRUSTEE_W *, ULONG *);
void DestroyAccessRequestList(PACCESS_REQUEST_W, ULONG *);
void DestroyTrusteeList(TRUSTEE_W *, ULONG *);
void DestroyExplicitAccessList(PEXPLICIT_ACCESS_W, ULONG *);
void PrintEnvironment(void);
void DumpTrusteeRecord(TRUSTEE_RECORD *);
void DumpAccessRequestList(ULONG, ACCESS_REQUEST_W []);
void DumpExplicitAccessList(ULONG, EXPLICIT_ACCESS_W []);
void DumpAccessPermissions(DWORD);
DWORD StringToAccessPermission(CHAR *);
void DumpAccessMode(ACCESS_MODE);
void DumpTrusteeList(ULONG, TRUSTEE_W []);
void DumpTrustee(TRUSTEE_W *);
void DumpMultipleTrusteeOperation(MULTIPLE_TRUSTEE_OPERATION);
MULTIPLE_TRUSTEE_OPERATION StringToMultipleTrusteeOperation(CHAR *);
void DumpTrusteeType(TRUSTEE_TYPE);
TRUSTEE_TYPE StringToTrusteeType(CHAR *);
void DumpTrusteeForm(TRUSTEE_FORM);
TRUSTEE_FORM StringToTrusteeForm(CHAR *);
void DumpSID(PISID);
ACCESS_MODE StringToAccessMode(CHAR *);
void DumpInheritance(DWORD);
DWORD StringToInheritance(CHAR *);
void ReleaseExplicitAccessList(ULONG, PEXPLICIT_ACCESS_W);
void CopyExplicitAccessList(PEXPLICIT_ACCESS_W, PEXPLICIT_ACCESS_W, ULONG *, ULONG);
void ExecTestServer(CHAR *);
void ExecRevertAccessRights(void);
void ExecCommitAccessRights(void);
void ExecGetClassID(void);
void ExecInitNewACL(void);
void ExecLoadACL(CHAR *);
void ExecSaveACL(CHAR *);
void ExecGetSizeMax(void);
void ExecIsDirty(void);
void ExecGrantAccessRights(void);
void ExecSetAccessRights(void);
void ExecDenyAccessRights(void);
void ExecReplaceAllAccessRights(void);
void ExecRevokeExplicitAccessRights(void);
void ExecIsAccessPermitted(void);
void ExecGetEffectiveAccessRights(void);
void ExecGetExplicitAccessRights(void);
void ExecCleanupProc();
void Usage(char * pszProgramName)
{
printf("Usage: %s\n", pszProgramName);
printf(" -m remote_server_name\n");
exit(1);
}
void stringtolower
(
char *pszString
)
{
char c;
while(c = *pszString)
{
if(c <= 'Z' && c >= 'A')
{
*pszString = c - 'A' + 'a';
}
pszString++;
}
} // stringtolower
void __cdecl main(int argc, char **argv)
{
RPC_STATUS status;
unsigned long ulCode;
WCHAR DummyChar;
int i;
char aLineBuff[LINE_BUFF_SIZE];
char *aTokens[MAX_TOKENS_NUM];
short iNumOfTokens;
SEC_WINNT_AUTH_IDENTITY_A auth_id;
UCHAR uname[STR_LEN];
UCHAR domain[STR_LEN];
UCHAR password[STR_LEN];
TRUSTEE_W DummyMultipleTrustee;
ULONG ulStrLen;
DWORD dwAccessPermission;
BOOL biBatchMode = FALSE;
HRESULT hr;
OLECHAR pwszRemoteServer[1024];
DWORD dwStrLen;
/* allow the user to override settings with command line switches */
for (i = 1; i < argc; i++) {
if ((*argv[i] == '-') || (*argv[i] == '/')) {
switch (tolower(*(argv[i]+1))) {
case 'm': // remote server name
dwStrLen = MultiByteToWideChar( CP_ACP
, NULL
, argv[++i]
, -1
, pwszRemoteServer
, 1024);
break;
case 'b':
biBatchMode = TRUE;
break;
case 'h':
case '?':
default:
Usage(argv[0]);
}
}
else
Usage(argv[0]);
}
// Initialize the testing environment
aTokens[0] = aLineBuff;
g_LocalTrusteeRecord.grfAccessPermissions = 0;
g_LocalTrusteeRecord.grfAccessMode = GRANT_ACCESS;
g_LocalTrusteeRecord.grfInheritance = NO_INHERITANCE;
g_LocalTrusteeRecord.pMultipleTrustee = NULL;
g_LocalTrusteeRecord.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
g_LocalTrusteeRecord.TrusteeForm = TRUSTEE_IS_NAME;
g_LocalTrusteeRecord.TrusteeType = TRUSTEE_IS_USER;
g_LocalTrusteeRecord.pwszTrusteeName = NULL;
g_LocalTrusteeRecord.pSID = NULL;
auth_id.User = uname;
auth_id.Domain = domain;
auth_id.Password = password;
auth_id.Flags = 0x01; // ANSI
// Call CoInitialize to initialize the com library
hr = CoInitialize(NULL);
if(FAILED(hr))
{
printf("Failed to initialize the COM library.");
exit(hr);
} // if
// Call CoInitializeSecurity
hr = CoInitializeSecurity( NULL
, -1
, NULL
, NULL
, RPC_C_AUTHN_LEVEL_CONNECT
, RPC_C_IMP_LEVEL_IMPERSONATE
, NULL
, EOAC_NONE
, NULL );
if(FAILED(hr))
{
printf("Failed to initialize the COM call security layer.\n");
exit(hr);
}
MULTI_QI MultiQI;
MultiQI.pIID = &IID_IUnknown;
MultiQI.pItf = NULL;
COSERVERINFO ServerInfo;
ServerInfo.pwszName = pwszRemoteServer;
ServerInfo.pAuthInfo = NULL;
ServerInfo.dwReserved1 = 0;
ServerInfo.dwReserved2 = 0;
// Call CoCreateInstance to create an access control test
// object
hr = CoCreateInstanceEx( CLSID_COAccessControlTest
, NULL
, CLSCTX_REMOTE_SERVER
, &ServerInfo
, 1
, &MultiQI);
if(FAILED(hr))
{
printf("CoCreateInstance failed with exit code %x.\n", hr);
exit(hr);
}
hr = MultiQI.hr;
g_pIUnknown = (IUnknown *)MultiQI.pItf;
if(FAILED(hr))
{
printf("Failed to create an instance of the access control test object.\n");
exit(hr);
}
hr = g_pIUnknown->QueryInterface(IID_IAccessControlTest, (void **)&g_pIAccessControlTest);
if(FAILED(hr))
{
printf("Failed to query for the IAccessControlTest interface.\n");
exit(hr);
}
printf("\n");
PrintEnvironment();
printf("\n");
/* Entering the interactive command loop */
for(;;)
{
// Print out prompt
if (!biBatchMode)
{
printf("Command>");
}
memset(aLineBuff, 0, LINE_BUFF_SIZE);
// Read input form user
gets(aLineBuff);
if (biBatchMode)
{
printf("%s\n",aLineBuff);
}
Tokenize(aLineBuff,aTokens,&iNumOfTokens);
// Process the tokens
stringtolower(aTokens[0]);
// Decode and execute command
// Ignore comments
if (iNumOfTokens == 0)
{
continue;
}
if (*aTokens[0] == '#')
{
continue;
}
printf("\n");
if (strcmp(aTokens[0],"quit") == 0)
{
printf("Exit.\n");
ExecCleanupProc();
break;
}
else if (strcmp(aTokens[0],"exit") == 0)
{
printf("Exit.\n");
ExecCleanupProc();
break;
}
else if (strcmp(aTokens[0],"sleep") == 0)
{
printf("Sleep for %s milliseconds", aTokens[1]);
Sleep(atoi(aTokens[1]));
}
else if (strcmp(aTokens[0], "testserver") == 0)
{
g_pIAccessControlTest->TestServer(aTokens[1]);
printf("Done.\n");
}
else if (strcmp(aTokens[0],"switchclientctx") == 0)
{
printf("User:");
gets((CHAR *)uname);
printf("Domain:");
gets((CHAR *)domain);
printf("Password:");
gets((CHAR *)password);
auth_id.UserLength = strlen((CHAR *)uname);
auth_id.DomainLength = strlen((CHAR *)domain);
auth_id.PasswordLength = strlen((CHAR *)password);
auth_id.Flags = 0x1;
/* Set authentication info so that the server is triggered */
/* to cache group info for the client from the domain server */
hr = CoSetProxyBlanket( g_pIAccessControlTest
, RPC_C_AUTHN_WINNT
, RPC_C_AUTHZ_NONE
, NULL
, RPC_C_AUTHN_LEVEL_CONNECT
, RPC_C_IMP_LEVEL_IMPERSONATE
, &auth_id
, EOAC_NONE );
printf("CoSetProxyBlanket returned %x\n", hr);
if (FAILED(hr))
{
exit(hr);
}
}
else if (strcmp(aTokens[0],"toggleaccessperm") == 0)
{
stringtolower(aTokens[1]);
dwAccessPermission = StringToAccessPermission(aTokens[1]);
if (g_LocalTrusteeRecord.grfAccessPermissions & dwAccessPermission)
{
g_LocalTrusteeRecord.grfAccessPermissions &= ~dwAccessPermission;
}
else
{
g_LocalTrusteeRecord.grfAccessPermissions |= dwAccessPermission;
}
printf("Done.\n");
}
else if (strcmp(aTokens[0],"set") == 0)
{
stringtolower(aTokens[1]);
if (strcmp(aTokens[1],"trusteename") == 0)
{
// The old SID in the global trustee record will no longer valid so we
// may as well release it to avoid confusion
if (g_LocalTrusteeRecord.pSID != NULL)
{
midl_user_free(g_LocalTrusteeRecord.pSID);
g_LocalTrusteeRecord.pSID = NULL;
}
if (g_LocalTrusteeRecord.pwszTrusteeName != NULL)
{
midl_user_free(g_LocalTrusteeRecord.pwszTrusteeName);
}
ulStrLen = MultiByteToWideChar( CP_ACP
, 0
, aTokens[2]
, -1
, &DummyChar
, 0 );
g_LocalTrusteeRecord.pwszTrusteeName = (LPWSTR)midl_user_allocate(sizeof(WCHAR) * (ulStrLen+1));
MultiByteToWideChar( CP_ACP
, 0
, aTokens[2]
, ulStrLen + 1
, g_LocalTrusteeRecord.pwszTrusteeName
, ulStrLen + 1);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "accessmode") == 0)
{
stringtolower(aTokens[2]);
g_LocalTrusteeRecord.grfAccessMode = StringToAccessMode(aTokens[2]);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "inheritance") == 0)
{
stringtolower(aTokens[2]);
g_LocalTrusteeRecord.grfInheritance = StringToInheritance(aTokens[2]);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "multipletrustee") == 0)
{
stringtolower(aTokens[2]);
if (strcmp(aTokens[2], "null") == 0)
{
g_LocalTrusteeRecord.pMultipleTrustee = NULL;
}
else
{
g_LocalTrusteeRecord.pMultipleTrustee = &DummyMultipleTrustee;
}
printf("Done.\n");
}
else if (strcmp(aTokens[1], "multipletrusteeoperation") == 0)
{
stringtolower(aTokens[2]);
g_LocalTrusteeRecord.MultipleTrusteeOperation = StringToMultipleTrusteeOperation(aTokens[2]);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteeform") == 0)
{
stringtolower(aTokens[2]);
g_LocalTrusteeRecord.TrusteeForm = StringToTrusteeForm(aTokens[2]);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteetype") == 0)
{
stringtolower(aTokens[2]);
g_LocalTrusteeRecord.TrusteeType = StringToTrusteeType(aTokens[2]);
printf("Done.\n");
}
else
{
printf("Invalid environment variable.\n");
} // if
}
else if (strcmp(aTokens[0], "getsidforcurrenttrustee") == 0)
{
g_LocalTrusteeRecord.pSID = GetSIDForTrustee(g_LocalTrusteeRecord.pwszTrusteeName);
printf("Done.\n");
}
else if (strcmp(aTokens[0], "addtrustee") == 0)
{
stringtolower(aTokens[1]);
if (strcmp(aTokens[1], "explicitaccesslist") == 0)
{
AddTrusteeToExplicitAccessList(&g_LocalTrusteeRecord, g_pLocalExplicitAccessList, &g_ulNumOfLocalExplicitAccesses);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "accessrequestlist") == 0)
{
AddTrusteeToAccessRequestList(&g_LocalTrusteeRecord, g_pLocalAccessRequestList, &g_ulNumOfLocalAccessRequests);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteelist") == 0)
{
AddTrusteeToTrusteeList(&g_LocalTrusteeRecord, g_pLocalTrusteeList, &g_ulNumOfLocalTrustees);
printf("Done.\n");
}
else
{
printf("Unknown list type.\n");
}
}
else if (strcmp(aTokens[0], "deletetrustee") == 0)
{
stringtolower(aTokens[2]);
if (strcmp(aTokens[2], "localexplicitaccesslist") == 0)
{
DeleteTrusteeFromExplicitAccessList(atoi(aTokens[1]), g_pLocalExplicitAccessList, &g_ulNumOfLocalExplicitAccesses);
printf("Done.\n");
}
else if (strcmp(aTokens[2], "accessrequestlist") == 0)
{
DeleteTrusteeFromAccessRequestList(atoi(aTokens[1]), g_pLocalAccessRequestList, &g_ulNumOfLocalAccessRequests);
printf("Done.\n");
}
else if (strcmp(aTokens[2], "trusteelist") == 0)
{
DeleteTrusteeFromTrusteeList(atoi(aTokens[1]), g_pLocalTrusteeList, &g_ulNumOfLocalTrustees);
printf("Done.\n");
}
else
{
printf("Unknown list type.\n");
}
}
else if (strcmp(aTokens[0], "destroy") == 0)
{
stringtolower(aTokens[1]);
if (strcmp(aTokens[1], "localexplicitaccesslist") == 0)
{
DestroyExplicitAccessList(g_pLocalExplicitAccessList, &g_ulNumOfLocalExplicitAccesses);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "returnedexplicitaccessslist") == 0)
{
DestroyExplicitAccessList(g_pReturnedExplicitAccessList, &g_ulNumOfExplicitAccessesReturned);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "accessrequestlist") == 0)
{
DestroyAccessRequestList(g_pLocalAccessRequestList, &g_ulNumOfLocalAccessRequests);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteelist") == 0)
{
DestroyTrusteeList(g_pLocalTrusteeList, &g_ulNumOfLocalTrustees);
}
else
{
printf("Unknown list type.");
}
}
else if (strcmp(aTokens[0], "view") == 0)
{
stringtolower(aTokens[1]);
if (strcmp(aTokens[1], "localexplicitaccesslist") == 0)
{
DumpExplicitAccessList(g_ulNumOfLocalExplicitAccesses, g_pLocalExplicitAccessList);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "returnedexplicitaccessslist") == 0)
{
DumpExplicitAccessList(g_ulNumOfExplicitAccessesReturned, g_pReturnedExplicitAccessList);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "accessrequestlist") == 0)
{
DumpAccessRequestList(g_ulNumOfLocalAccessRequests, g_pLocalAccessRequestList);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteelist") == 0)
{
DumpTrusteeList(g_ulNumOfLocalTrustees, g_pLocalTrusteeList);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "trusteerecord") == 0)
{
DumpTrusteeRecord(&g_LocalTrusteeRecord);
printf("Done.\n");
}
else if (strcmp(aTokens[1], "localenvironment") == 0)
{
PrintEnvironment();
}
else
{
printf("Invalid argument.");
}
}
else if (strcmp(aTokens[0], "copyreturnedlist") == 0)
{
// release the old local explicit access list
ReleaseExplicitAccessList(g_ulNumOfLocalExplicitAccesses, g_pLocalExplicitAccessList);
// replace the local explicit acccess list with the explicit access list returned
// from the last call to GetExplicitAccess
CopyExplicitAccessList(g_pLocalExplicitAccessList, g_pReturnedExplicitAccessList, &g_ulNumOfLocalExplicitAccesses, g_ulNumOfExplicitAccessesReturned);
printf("Done.\n");
}
else if (strcmp(aTokens[0], "exec") == 0)
{
stringtolower(aTokens[1]);
if (strcmp(aTokens[1], "testserver") == 0)
{
ExecTestServer(aTokens[2]);
}
else if (strcmp(aTokens[1], "revertaccessrights") == 0)
{
ExecRevertAccessRights();
}
else if (strcmp(aTokens[1], "commitaccessrights") == 0)
{
ExecCommitAccessRights();
}
else if (strcmp(aTokens[1], "getclassid") == 0)
{
ExecGetClassID();
}
else if (strcmp(aTokens[1], "initnewacl") == 0)
{
ExecInitNewACL();
}
else if (strcmp(aTokens[1], "loadacl") == 0)
{
ExecLoadACL(aTokens[2]);
}
else if (strcmp(aTokens[1], "saveacl") == 0)
{
ExecSaveACL(aTokens[2]);
}
else if (strcmp(aTokens[1], "isdirty") == 0)
{
ExecIsDirty();
}
else if (strcmp(aTokens[1], "getsizemax") == 0)
{
ExecGetSizeMax();
}
else if (strcmp(aTokens[1], "grantaccessrights") == 0)
{
ExecGrantAccessRights();
}
else if (strcmp(aTokens[1], "setaccessrights") == 0)
{
ExecSetAccessRights();
}
else if (strcmp(aTokens[1], "denyaccessrights") == 0)
{
ExecDenyAccessRights();
}
else if (strcmp(aTokens[1], "replaceallaccessrights") == 0)
{
ExecReplaceAllAccessRights();
}
else if (strcmp(aTokens[1], "revokeexplicitaccessrights") == 0)
{
ExecRevokeExplicitAccessRights();
}
else if (strcmp(aTokens[1], "isaccesspermitted") == 0)
{
ExecIsAccessPermitted();
}
else if (strcmp(aTokens[1], "geteffectiveaccessrights") == 0)
{
ExecGetEffectiveAccessRights();
}
else if (strcmp(aTokens[1], "getexplicitaccessrights") == 0)
{
ExecGetExplicitAccessRights();
}
else
{
printf("Unknown command.\n");
}
}
else
{
printf("Unrecognized command.\n");
} // if
printf("\n");
} // for
exit(0);
} // end main()
PISID GetSIDForTrustee
(
LPWSTR pwszTrusteeName
)
{
PISID pSID;
DWORD dwSize = 0;
WCHAR pwszDomain[100];
DWORD dwDomainSize = 100;
SID_NAME_USE SIDUse;
LookupAccountNameW( NULL
, pwszTrusteeName
, pSID
, &dwSize
, pwszDomain
, &dwDomainSize
, &SIDUse );
pSID = (PISID)midl_user_allocate(dwSize);
LookupAccountNameW( NULL
, pwszTrusteeName
, pSID
, &dwSize
, pwszDomain
, &dwDomainSize
, &SIDUse );
return pSID;
}
void AddTrusteeToExplicitAccessList
(
TRUSTEE_RECORD *pTrusteeRecord,
PEXPLICIT_ACCESS_W pExplicitAccessList,
ULONG *pulNumOfExplicitAccesses
)
{
PEXPLICIT_ACCESS_W pInsertionPoint;
pInsertionPoint = pExplicitAccessList + *pulNumOfExplicitAccesses;
pInsertionPoint->grfAccessPermissions = pTrusteeRecord->grfAccessPermissions;
pInsertionPoint->grfAccessMode = pTrusteeRecord->grfAccessMode;
pInsertionPoint->grfInheritance = pTrusteeRecord->grfInheritance;
MapTrusteeRecordToTrustee(pTrusteeRecord, &(pInsertionPoint->Trustee));
(*pulNumOfExplicitAccesses)++;
}
void DeleteTrusteeFromExplicitAccessList
(
ULONG ulIndex,
PEXPLICIT_ACCESS_W pExplicitAccessList,
ULONG *pulNumOfExplicitAccesses
)
{
PEXPLICIT_ACCESS_W pDeletionPoint;
if(ulIndex >= *pulNumOfExplicitAccesses)
{
return;
}
pDeletionPoint = pExplicitAccessList + ulIndex;
midl_user_free(pDeletionPoint->Trustee.ptstrName);
(*pulNumOfExplicitAccesses)--;
memmove(pDeletionPoint, pDeletionPoint + 1, sizeof(EXPLICIT_ACCESS_W) * (*pulNumOfExplicitAccesses - ulIndex));
}
void AddTrusteeToAccessRequestList
(
TRUSTEE_RECORD *pTrusteeRecord,
PACCESS_REQUEST_W pAccessRequestList,
ULONG *pulNumOfAccessRequests
)
{
PACCESS_REQUEST_W pInsertionPoint;
pInsertionPoint = pAccessRequestList + *pulNumOfAccessRequests;
pInsertionPoint->grfAccessPermissions = pTrusteeRecord->grfAccessPermissions;
MapTrusteeRecordToTrustee(pTrusteeRecord, &(pInsertionPoint->Trustee));
(*pulNumOfAccessRequests)++;
}
void DeleteTrusteeFromAccessRequestList
(
ULONG ulIndex,
PACCESS_REQUEST_W pAccessRequestList,
ULONG *pulNumOfAccessRequests
)
{
PACCESS_REQUEST_W pDeletionPoint;
pDeletionPoint = pAccessRequestList + ulIndex;
if (ulIndex >= *pulNumOfAccessRequests)
{
return;
}
midl_user_free(pDeletionPoint->Trustee.ptstrName);
(*pulNumOfAccessRequests)--;
memmove(pDeletionPoint, pDeletionPoint + 1, sizeof(ACCESS_REQUEST_W) * (*pulNumOfAccessRequests - ulIndex));
}
void MapTrusteeRecordToTrustee
(
TRUSTEE_RECORD *pTrusteeRecord,
TRUSTEE_W *pTrustee
)
{
ULONG ulTrusteeNameLength;
pTrustee->pMultipleTrustee = pTrusteeRecord->pMultipleTrustee;
pTrustee->MultipleTrusteeOperation = pTrusteeRecord->MultipleTrusteeOperation;
pTrustee->TrusteeForm = pTrusteeRecord->TrusteeForm;
pTrustee->TrusteeType = pTrusteeRecord->TrusteeType;
switch(pTrusteeRecord->TrusteeForm)
{
case TRUSTEE_IS_SID:
if(pTrusteeRecord->pSID== NULL)
{
pTrustee->ptstrName = NULL;
}
else
{
ulTrusteeNameLength = GetSidLengthRequired(pTrusteeRecord->pSID->SubAuthorityCount);
pTrustee->ptstrName = (LPWSTR)midl_user_allocate(ulTrusteeNameLength);
CopySid(ulTrusteeNameLength, (PSID)(pTrustee->ptstrName), pTrusteeRecord->pSID);
}
break;
case TRUSTEE_IS_NAME:
if (pTrusteeRecord->pwszTrusteeName == NULL)
{
pTrustee->ptstrName = NULL;
}
else
{
ulTrusteeNameLength = lstrlenW(pTrusteeRecord->pwszTrusteeName);
pTrustee->ptstrName = (LPWSTR)midl_user_allocate((ulTrusteeNameLength + 1) * sizeof(WCHAR));
lstrcpyW(pTrustee->ptstrName, pTrusteeRecord->pwszTrusteeName);
}
break;
}
}
void AddTrusteeToTrusteeList
(
TRUSTEE_RECORD *pTrusteeRecord,
TRUSTEE_W *pTrusteeList,
ULONG *pulNumOfTrustees
)
{
TRUSTEE_W *pInsertionPoint;
pInsertionPoint = pTrusteeList + *pulNumOfTrustees;
MapTrusteeRecordToTrustee(pTrusteeRecord, pInsertionPoint);
(*pulNumOfTrustees)++;
}
void DeleteTrusteeFromTrusteeList
(
ULONG ulIndex,
TRUSTEE_W *pTrusteeList,
ULONG *pulNumOfTrustees
)
{
TRUSTEE_W *pDeletionPoint;
pDeletionPoint = pTrusteeList + ulIndex;
if (ulIndex >= *pulNumOfTrustees)
{
return;
}
midl_user_free(pDeletionPoint->ptstrName);
(*pulNumOfTrustees)--;
memmove(pDeletionPoint, pDeletionPoint + 1, sizeof(TRUSTEE_W) * (*pulNumOfTrustees - ulIndex));
}
void DestroyAccessRequestList
(
PACCESS_REQUEST_W pAccessRequestList,
ULONG *pulNumOfAccessRequests
)
{
ULONG i;
PACCESS_REQUEST_W pAccessRequestListPtr;
for ( i = 0, pAccessRequestListPtr = pAccessRequestList
; i < *pulNumOfAccessRequests
; i++, pAccessRequestListPtr++)
{
midl_user_free(pAccessRequestListPtr->Trustee.ptstrName);
}
*pulNumOfAccessRequests = 0;
}
void DestroyTrusteeList
(
TRUSTEE_W *pTrusteeList,
ULONG *pulNumOfTrustees
)
{
ULONG i;
TRUSTEE_W *pTrusteeListPtr;
for ( i = 0, pTrusteeListPtr = pTrusteeList
; i < *pulNumOfTrustees
; i++, pTrusteeListPtr++)
{
midl_user_free(pTrusteeListPtr->ptstrName);
}
*pulNumOfTrustees = 0;
}
void DestroyExplicitAccessList
(
PEXPLICIT_ACCESS_W pExplicitAccessList,
ULONG *pulNumOfExplicitAccesses
)
{
ReleaseExplicitAccessList(*pulNumOfExplicitAccesses, pExplicitAccessList);
*pulNumOfExplicitAccesses = 0;
}
/*
Function: PrintEnvironment
Parameter: none
Return: void
Purpose: This function prints out the current setting of the
client side global varibles.
*/
void PrintEnvironment
(
void
)
{
printf("Local access request list:\n");
DumpAccessRequestList(g_ulNumOfLocalAccessRequests, g_pLocalAccessRequestList);
printf("Local explicit access list:\n");
DumpExplicitAccessList(g_ulNumOfLocalExplicitAccesses, g_pLocalExplicitAccessList);
printf("Local trustee list:\n");
DumpTrusteeList(g_ulNumOfLocalTrustees, g_pLocalTrusteeList);
printf("The explicit access list returned form the last call to GetExplicitAccessRights:\n");
DumpExplicitAccessList(g_ulNumOfExplicitAccessesReturned, g_pReturnedExplicitAccessList);
printf("Current trustee record:\n");
DumpTrusteeRecord(&g_LocalTrusteeRecord);
} // PrintEnvironment
void DumpTrusteeRecord
(
TRUSTEE_RECORD *pTrusteeRecord
)
{
CHAR pszTrusteeName[200];
ULONG ulStrLen;
printf("Access permissions:\n");
DumpAccessPermissions(pTrusteeRecord->grfAccessPermissions);
printf("Access mode: ");
DumpAccessMode(pTrusteeRecord->grfAccessMode);
printf("Inheritance: ");
DumpInheritance(pTrusteeRecord->grfInheritance);
printf("pMultipleTrustree is ");
if(pTrusteeRecord->pMultipleTrustee == NULL)
{
printf("NULL.\n");
}
else
{
printf("non-NULL.\n");
}
printf("MultipleTrusteeOperation: ");
DumpMultipleTrusteeOperation(pTrusteeRecord->MultipleTrusteeOperation);
printf("TrusteeForm: ");
DumpTrusteeForm(pTrusteeRecord->TrusteeForm);
printf("TrusteeType: ");
DumpTrusteeType(pTrusteeRecord->TrusteeType);
if (pTrusteeRecord->pwszTrusteeName == NULL)
{
strcpy(pszTrusteeName, "<NULL>");
}
else
{
ulStrLen = WideCharToMultiByte( CP_ACP
, 0
, pTrusteeRecord->pwszTrusteeName
, -1
, pszTrusteeName
, 200
, NULL
, NULL );
}
printf("Trustee's name: %s\n", pszTrusteeName);
printf("Trustee's SID: \n");
DumpSID(pTrusteeRecord->pSID);
printf("\n");
}
void DumpAccessRequestList
(
ULONG ulNumOfEntries,
ACCESS_REQUEST_W pAccessRequestList[]
)
{
ULONG i;
PACCESS_REQUEST_W pLocalAccessRequestListPtr;
for (i = 0, pLocalAccessRequestListPtr = pAccessRequestList; i < ulNumOfEntries; i++, pLocalAccessRequestListPtr++)
{
printf("Access request #%d:\n\n", i);
printf("Access permissions: ");
DumpAccessPermissions(pLocalAccessRequestListPtr->grfAccessPermissions);
printf("Trustee: \n");
DumpTrustee(&(pLocalAccessRequestListPtr->Trustee));
printf("\n");
}
}
/*
Function: DumpLocalExplicitAccessList
Parameters: ULONG ulNumOfEntries - Number of EXPLICIT_ACCESS structures in the array
EXPLICIT_ACCESS_W pExplicitAccessList - Pointer to an array of EXPLICIT_ACCESS structures to be printed
to be printed to the console.
Purpose: This function prints an array of explicit access structures to the console
*/
void DumpExplicitAccessList
(
ULONG ulNumOfEntries,
EXPLICIT_ACCESS_W pExplicitAccessList[]
)
{
ULONG i; // Loop counter
EXPLICIT_ACCESS_W *pLocalExplicitAccessListPtr; // Local pointer for stepping through the explicit access list
for (pLocalExplicitAccessListPtr = pExplicitAccessList, i = 0; i < ulNumOfEntries; i++, pLocalExplicitAccessListPtr++)
{
printf("Entry #%d.\n\n", i);
printf("Access permissions:\n");
DumpAccessPermissions(pLocalExplicitAccessListPtr->grfAccessPermissions);
printf("Access mode: ");
DumpAccessMode(pLocalExplicitAccessListPtr->grfAccessMode);
printf("Inheritance: ");
DumpInheritance(pLocalExplicitAccessListPtr->grfInheritance);
printf("Trustee:\n");
DumpTrustee(&(pLocalExplicitAccessListPtr->Trustee));
printf("End Of entry #%d.\n\n", i);
} // for
} // DumpLocalExplicitAccessList
void DumpAccessPermissions
(
DWORD grfAccessPermissions
)
{
if(grfAccessPermissions & COM_RIGHTS_EXECUTE)
{
printf("COM_RIGHTS_EXECUTE\n");
}
if(grfAccessPermissions & BOGUS_ACCESS_RIGHT1)
{
printf("BOGUS_ACCESS_RIGHT1\n");
}
if(grfAccessPermissions & BOGUS_ACCESS_RIGHT2)
{
printf("BOGUS_ACCESS_RIGHT2\n");
}
if(grfAccessPermissions & BOGUS_ACCESS_RIGHT3)
{
printf("BOGUS_ACCESS_RIGHT3\n");
}
if(grfAccessPermissions & BOGUS_ACCESS_RIGHT4)
{
printf("BOGUS_ACCESS_RIGHT4\n");
}
}
DWORD StringToAccessPermission
(
CHAR *pszString
)
{
if (strcmp(pszString, "com_rights_execute") == 0)
{
return COM_RIGHTS_EXECUTE;
}
if (strcmp(pszString, "bogus_access_right1") == 0)
{
return BOGUS_ACCESS_RIGHT1;
}
if (strcmp(pszString, "bogus_access_right2") == 0)
{
return BOGUS_ACCESS_RIGHT2;
}
if (strcmp(pszString, "bogus_access_right3") == 0)
{
return BOGUS_ACCESS_RIGHT3;
}
if (strcmp(pszString, "bogus_access_right4") == 0)
{
return BOGUS_ACCESS_RIGHT4;
}
return 0;
}
void DumpAccessMode
(
ACCESS_MODE grfAccessMode
)
{
switch(grfAccessMode)
{
case NOT_USED_ACCESS:
printf("NOT_USED_ACCESS\n");
break;
case GRANT_ACCESS:
printf("GRANT_ACCESS\n");
break;
case DENY_ACCESS:
printf("DENY_ACCESS\n");
break;
case SET_ACCESS:
printf("SET_ACCESS\n");
break;
case REVOKE_ACCESS:
printf("REVOKE_ACCESS\n");
break;
case SET_AUDIT_SUCCESS:
printf("SET_AUDIT_SUCCESS\n");
break;
case SET_AUDIT_FAILURE:
printf("SET_AUDIT_FAILURE\n");
break;
} // switch
} // DumpAccessMode
void DumpTrusteeList
(
ULONG ulNumOfTrustees,
TRUSTEE_W pTrusteeList[]
)
{
ULONG i;
PTRUSTEE_W pTrusteeListPtr;
for( i = 0, pTrusteeListPtr = pTrusteeList
; i < ulNumOfTrustees
; i++, pTrusteeListPtr++)
{
printf("Trustee #%d:\n", i);
DumpTrustee(pTrusteeListPtr);
printf("\n");
}
}
void DumpTrustee
(
TRUSTEE_W *pTrustee
)
{
char pszTrusteeName[256];
ULONG ulStrLen;
printf("pMultipleTrustee is ");
if(pTrustee->pMultipleTrustee == NULL)
{
printf("NULL.\n");
}
else
{
printf("non-NULL.\n");
}
printf("MultipleTrusteeOperation: ");
DumpMultipleTrusteeOperation(pTrustee->MultipleTrusteeOperation);
printf("TrusteeForm: ");
DumpTrusteeForm(pTrustee->TrusteeForm);
printf("TrusteeType: ");
DumpTrusteeType(pTrustee->TrusteeType);
switch(pTrustee->TrusteeForm)
{
case TRUSTEE_IS_NAME:
if (pTrustee->ptstrName == NULL)
{
strcpy(pszTrusteeName, "<NULL>");
}
else
{
ulStrLen = WideCharToMultiByte( CP_ACP
, 0
, pTrustee->ptstrName
, -1
, pszTrusteeName
, 256
, NULL
, NULL );
pszTrusteeName[ulStrLen] = '\0';
}
printf("Trustee's name is: %s\n", pszTrusteeName);
break;
case TRUSTEE_IS_SID:
printf("Trustee's SID is:\n");
DumpSID((PISID)(pTrustee->ptstrName));
break;
} // switch
}
void DumpMultipleTrusteeOperation
(
MULTIPLE_TRUSTEE_OPERATION MultipleTrusteeOperation
)
{
switch(MultipleTrusteeOperation)
{
case NO_MULTIPLE_TRUSTEE:
printf("NO_MULTIPLE_TRUSTEE\n");
break;
case TRUSTEE_IS_IMPERSONATE:
printf("TRUSTEE_IS_IMPERSONATE\n");
break;
}
}
MULTIPLE_TRUSTEE_OPERATION StringToMultipleTrusteeOperation
(
CHAR *pszString
)
{
if(strcmp(pszString, "no_multiple_trustee") == 0)
{
return NO_MULTIPLE_TRUSTEE;
}
if(strcmp(pszString, "trustee_is_impersonate") == 0)
{
return TRUSTEE_IS_IMPERSONATE;
}
return NO_MULTIPLE_TRUSTEE;
}
void DumpTrusteeType
(
TRUSTEE_TYPE TrusteeType
)
{
switch (TrusteeType)
{
case TRUSTEE_IS_UNKNOWN:
printf("TRUSTEE_IS_UNKNOWN\n");
break;
case TRUSTEE_IS_USER:
printf("TRUSTEE_IS_USER\n");
break;
case TRUSTEE_IS_GROUP:
printf("TRSUTEE_IS_GROUP\n");
break;
}
}
TRUSTEE_TYPE StringToTrusteeType
(
CHAR *pszString
)
{
if(strcmp(pszString, "trustee_is_unknown") == 0)
{
return TRUSTEE_IS_UNKNOWN;
}
if(strcmp(pszString, "trustee_is_user") == 0)
{
return TRUSTEE_IS_USER;
}
if(strcmp(pszString, "trustee_is_group") == 0)
{
return TRUSTEE_IS_GROUP;
}
return TRUSTEE_IS_UNKNOWN;
}
void DumpTrusteeForm
(
TRUSTEE_FORM TrusteeForm
)
{
switch (TrusteeForm)
{
case TRUSTEE_IS_NAME:
printf("TRUSTEE_IS_NAME\n");
break;
case TRUSTEE_IS_SID:
printf("TRUSTEE_IS_SID\n");
break;
}
}
TRUSTEE_FORM StringToTrusteeForm
(
CHAR *pszString
)
{
if (strcmp(pszString, "trustee_is_name") == 0)
{
return TRUSTEE_IS_NAME;
}
if (strcmp(pszString, "trustee_is_sid") == 0)
{
return TRUSTEE_IS_SID;
}
return TRUSTEE_IS_NAME;
}
void DumpSID
(
PISID pSID
)
{
ULONG i;
if( pSID == NULL)
{
printf("<NULL>\n");
}
else
{
printf("Revision: %d\n", pSID->Revision);
printf("SubAuthorityCount: %d\n", pSID->SubAuthorityCount);
printf("IdentifierAuthority: {%d,%d,%d,%d,%d,%d}\n", (pSID->IdentifierAuthority.Value)[0]
, (pSID->IdentifierAuthority.Value)[1]
, (pSID->IdentifierAuthority.Value)[2]
, (pSID->IdentifierAuthority.Value)[3]
, (pSID->IdentifierAuthority.Value)[4]
, (pSID->IdentifierAuthority.Value)[5] );
printf("SubAuthorities:\n");
for (i = 0; i < pSID->SubAuthorityCount; i++)
{
printf("%d\n", pSID->SubAuthority[i]);
}
}
}
ACCESS_MODE StringToAccessMode
(
CHAR *pszString
)
{
if(strcmp(pszString, "not_use_access") == 0)
{
return NOT_USED_ACCESS;
}
if(strcmp(pszString, "grant_access") == 0)
{
return GRANT_ACCESS;
}
if(strcmp(pszString, "set_access") == 0)
{
return SET_ACCESS;
}
if(strcmp(pszString, "deny_access") == 0)
{
return DENY_ACCESS;
}
if(strcmp(pszString, "revoke_access") == 0)
{
return REVOKE_ACCESS;
}
if(strcmp(pszString, "set_audit_success") == 0)
{
return SET_AUDIT_SUCCESS;
}
if(strcmp(pszString, "set_audit_failure") == 0)
{
return SET_AUDIT_FAILURE;
}
return NOT_USED_ACCESS;
}
void DumpInheritance
(
DWORD grfInheritance
)
{
switch(grfInheritance)
{
case NO_INHERITANCE:
printf("NO_INHERITANCE\n");
break;
case SUB_CONTAINERS_ONLY_INHERIT:
printf("SUB_CONTAINERS_ONLY_INHERIT\n");
break;
case SUB_OBJECTS_ONLY_INHERIT:
printf("SUB_OBJECTS_ONLY_INHERIT\n");
break;
case SUB_CONTAINERS_AND_OBJECTS_INHERIT:
printf("SUB_CONTAINERS_AND_OBJECTS_INHERIT\n");
break;
}
}
DWORD StringToInheritance
(
CHAR *pszString
)
{
if (strcmp(pszString, "no_inheritance") == 0)
{
return NO_INHERITANCE;
}
if (strcmp(pszString, "sub_containers_only_inherit") == 0)
{
return SUB_CONTAINERS_ONLY_INHERIT;
}
if (strcmp(pszString, "sub_objects_only_inherit") == 0)
{
return SUB_OBJECTS_ONLY_INHERIT;
}
if (strcmp(pszString, "sub_containers_and_objects_inherit") == 0)
{
return SUB_CONTAINERS_AND_OBJECTS_INHERIT;
}
return 0;
}
void ReleaseExplicitAccessList
(
ULONG cCount,
PEXPLICIT_ACCESS_W pExplicitAccessList
)
{
ULONG i;
for (i = 0; i < cCount; i++)
{
midl_user_free(pExplicitAccessList[i].Trustee.ptstrName);
}
if(pExplicitAccessList != g_pLocalExplicitAccessList)
{
midl_user_free(pExplicitAccessList);
}
}
void CopyExplicitAccessList
(
PEXPLICIT_ACCESS_W pTarget,
PEXPLICIT_ACCESS_W pSource,
ULONG *pcCount,
ULONG cCount
)
{
ULONG i;
PEXPLICIT_ACCESS_W pTargetPtr;
PEXPLICIT_ACCESS_W pSourcePtr;
ULONG ulTrusteeNameSize;
for ( i = 0, pTargetPtr = pTarget, pSourcePtr = pSource
; i < cCount
; i++, pTargetPtr++, pSourcePtr++)
{
memcpy(pTargetPtr, pSourcePtr, sizeof(EXPLICIT_ACCESS));
switch(pTargetPtr->Trustee.TrusteeForm)
{
case TRUSTEE_IS_SID:
ulTrusteeNameSize = GetSidLengthRequired(((PISID)(pTargetPtr->Trustee.ptstrName))->SubAuthorityCount);
pTargetPtr->Trustee.ptstrName = (LPWSTR)midl_user_allocate(ulTrusteeNameSize);
CopySid(ulTrusteeNameSize, (PISID)(pTargetPtr->Trustee.ptstrName), (PISID)(pSourcePtr->Trustee.ptstrName));
break;
case TRUSTEE_IS_NAME:
ulTrusteeNameSize = lstrlenW(pSourcePtr->Trustee.ptstrName);
pTargetPtr->Trustee.ptstrName = (LPWSTR)midl_user_allocate((ulTrusteeNameSize + 1) * sizeof(WCHAR));
lstrcpyW(pTargetPtr->Trustee.ptstrName, pSourcePtr->Trustee.ptstrName);
break;
}
}
*pcCount = cCount;
}
void ExecTestServer
(
CHAR *pszTestString
)
{
ULONG ulCode;
HRESULT hr;
printf("Calling TestServer.\n");
g_pIAccessControlTest->TestServer(pszTestString);
} // ExecTestServer
void ExecRevertAccessRights
(
void
)
{
ULONG ulCode;
HRESULT hr;
printf("Calling RevertAccessRights.\n");
hr = g_pIAccessControlTest->RevertAccessRights();
if(hr == E_NOTIMPL)
{
printf("hr is E_NOTIMPL.\n");
}
} // ExecRevertAccessRights
void ExecCommitAccessRights
(
void
)
{
ULONG ulCode;
HRESULT hr;
printf("Calling CommitAccessRights.\n");
hr = g_pIAccessControlTest->CommitAccessRights(0);
if(hr == E_NOTIMPL)
{
printf("hr is E_NOTIMPL.\n");
}
} // ExecCommitAccessRights
void ExecGetClassID
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
CLSID clsid;
HRESULT hr;
printf("Calling GetClassID.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->GetClassID(&clsid, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
printf("The clsid returned is {%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}.\n"
, clsid.Data1, clsid.Data2, clsid.Data3
, clsid.Data4[0], clsid.Data4[1], clsid.Data4[2]
, clsid.Data4[3], clsid.Data4[4], clsid.Data4[5]
, clsid.Data4[6], clsid.Data4[7]);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecGetSizeMax
void ExecInitNewACL
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling InitNewACL.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->InitNewACL(&dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecInitNewACL
void ExecLoadACL
(
CHAR *pszFilename
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling LoadACL.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->LoadACL(pszFilename, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecLoadACL
void ExecSaveACL
(
CHAR *pszFilename
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
ULONG ulNumOfBytesWritten;
HRESULT hr;
printf("Calling SaveACL.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->SaveACL(pszFilename, TRUE, &ulNumOfBytesWritten, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The number of bytes written to the file was %d\n", ulNumOfBytesWritten);
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecSaveACL
void ExecGetSizeMax
(
void
)
{
ULONG ulCode;
DWORD dwTotalTickCount;
DOUBLE dMillisec;
ULONG ulNumOfBytesRequired;
HRESULT hr;
printf("Calling GetSizeMax.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->GetSizeMax(&ulNumOfBytesRequired, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The number of bytes required to save the ACL was %d\n", ulNumOfBytesRequired);
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecGetSizeMax
void ExecIsDirty
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling IsDirty.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->IsDirty(&dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
if(hr == S_OK)
{
printf("The access control object was dirty.\n");
}
else
{
printf("The access control object was clean.\n");
}
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecIsDirty
void ExecGrantAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling GrantAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->GrantAccessRights(g_ulNumOfLocalAccessRequests, (PE_ACCESS_REQUEST)(g_pLocalAccessRequestList), &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecGrantAccessRights
void ExecSetAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling SetAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->SetAccessRights(g_ulNumOfLocalAccessRequests, (PE_ACCESS_REQUEST)g_pLocalAccessRequestList, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecSetAccessRights
void ExecDenyAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling DenyAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->DenyAccessRights(g_ulNumOfLocalAccessRequests, (PE_ACCESS_REQUEST)g_pLocalAccessRequestList, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecDenyAccessRights
void ExecReplaceAllAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling ReplaceAllAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->ReplaceAllAccessRights(g_ulNumOfLocalExplicitAccesses, (PE_EXPLICIT_ACCESS)g_pLocalExplicitAccessList, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecReplaceAllAccessRights
void ExecRevokeExplicitAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
printf("Calling RevokeExplicitAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->RevokeExplicitAccessRights(g_ulNumOfLocalTrustees, (PE_TRUSTEE)g_pLocalTrusteeList, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecRevokeExplicitAccessRights
void ExecIsAccessPermitted
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
TRUSTEE_W Trustee;
MapTrusteeRecordToTrustee(&g_LocalTrusteeRecord, &Trustee);
printf("Calling IsAccessPermitted.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->IsAccessPermitted((PE_TRUSTEE)&Trustee, g_LocalTrusteeRecord.grfAccessPermissions, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if (hr == S_OK)
{
printf("The current trustee is granted the current set of access rights.\n");
}
else if (hr == E_ACCESSDENIED)
{
printf("The current trustee is denied the current set of access rights.\n");
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecIsAccessPermitted
void ExecGetEffectiveAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
TRUSTEE_W Trustee;
DWORD dwRights;
MapTrusteeRecordToTrustee(&g_LocalTrusteeRecord, &Trustee);
printf("Calling GetEffectiveAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->GetEffectiveAccessRights((PE_TRUSTEE)&Trustee, &dwRights, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
printf("The set of effective access rights available to the current trustee includes:\n");
DumpAccessPermissions(dwRights);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecGetEffectiveAccessRights
void ExecGetExplicitAccessRights
(
void
)
{
ULONG ulCode;
DOUBLE dMillisec;
DWORD dwTotalTickCount;
HRESULT hr;
// If the global retruned explicit access list pointer is not NULL,
// release the old returned explicit access list
if (g_pReturnedExplicitAccessList != NULL)
{
ReleaseExplicitAccessList(g_ulNumOfExplicitAccessesReturned, g_pReturnedExplicitAccessList);
} // if
g_pReturnedExplicitAccessList = NULL;
printf("Calling GetExplicitAccessRights.\n");
dwTotalTickCount = GetTickCount();
hr = g_pIAccessControlTest->GetExplicitAccessRights(&g_ulNumOfExplicitAccessesReturned, (PE_EXPLICIT_ACCESS *)&g_pReturnedExplicitAccessList, &dMillisec);
dwTotalTickCount = GetTickCount() - dwTotalTickCount;
if(SUCCEEDED(hr))
{
printf("The command was executed successfully on the server side with a return code of %x.\n", hr);
printf("The number of explicit access structures returned is %d.\n", g_ulNumOfExplicitAccessesReturned);
printf("The returned explicit access list is as follows:\n");
DumpExplicitAccessList(g_ulNumOfExplicitAccessesReturned, g_pReturnedExplicitAccessList);
}
else
{
printf("Execution of the command failed on the server side with a return code of %x.\n", hr);
} // if
printf("The time spent on the server side to execute the command was %fms.\n", dMillisec);
printf("The total number of clock ticks spent on the DCOM call was %d.\n", dwTotalTickCount);
} // ExecGetExplicitAccessRights
void ExecCleanupProc
(
void
)
{
ULONG ulCode;
// Release the IAccessControlTest pointer
g_pIAccessControlTest->Release();
g_pIUnknown->Release();
// Cleanup all the memory allocated for the Local list
DestroyAccessRequestList(g_pLocalAccessRequestList, &g_ulNumOfLocalAccessRequests);
DestroyTrusteeList(g_pLocalTrusteeList, &g_ulNumOfLocalTrustees);
DestroyExplicitAccessList(g_pLocalExplicitAccessList, &g_ulNumOfLocalExplicitAccesses);
DestroyExplicitAccessList(g_pReturnedExplicitAccessList, &g_ulNumOfExplicitAccessesReturned);
} // ExecCleanupProc
/*
Function: Tokenize
Parameters: [in] char *pLineBuffer
[out] char *pTokens[]
[out] short *piNumOfTokens
Return: void
Purpose: This function partition a string of space delimited tokens
to null delimited tokens and return pointers to each individual
token in pTokens and the number of tokens ion the string in
piNumOfTokens.
Comment: Memory for the array of char * Tokens should be allocated by
the caller.
This function is implemented as a simple finite state machine.
State 0 - Outside a token
State 1 - Inside a token
*/
void Tokenize
(
char * pLineBuffer,
char * pTokens[],
short * piNumOfTokens
)
{
short iTokens = 0; // Token index
char *pLBuffPtr = pLineBuffer; // Pointer in the line buffer
char c; // current character
short state = 0; // State of the tokenizing machine
for(;;)
{
c = *pLBuffPtr;
switch(state)
{
case 0:
switch(c)
{
case '\t': // Ignore blanks
case ' ':
case '\n':
break;
case '\0':
goto end;
default:
state=1;
pTokens[iTokens]=pLBuffPtr;
break;
} // switch
break;
case 1:
switch(c)
{
case '\t':
case ' ':
case '\n':
*pLBuffPtr='\0';
iTokens++;
state=0;
break;
case '\0':
*pLBuffPtr='\0';
iTokens++;
pTokens[iTokens]=pLBuffPtr;
goto end;
default:
break;
}
break;
}
pLBuffPtr++;
}// switch
end:
*piNumOfTokens = iTokens;
return;
} // Tokenize
/*********************************************************************/
/* MIDL allocate and free */
/*********************************************************************/
void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
{
return(CoTaskMemAlloc(len));
}
void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
{
CoTaskMemFree(ptr);
}
/* end file actestc.c */
Reference in a new issue Copy permalink