You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
8.9 KiB
297 lines
8.9 KiB
#include <windows.h>
|
|
#include "crtdbg.h"
|
|
#include <objbase.h>
|
|
#include "ISAUsInf.h"
|
|
|
|
PSID g_pSidEverybody = NULL;
|
|
LONG g_pSidEverybodyLenght = 0;
|
|
PSID g_pSidAdmins = NULL;
|
|
LONG g_pSidAdminsLenght = 0;
|
|
|
|
VARIANT_BOOL UserSidFound(PSID psidSAUser, LONG psidSAUserLength, PSID ppsidAAUsers[], LONG ppsidAAUsersLength[], DWORD dwNumAASids)
|
|
{
|
|
DWORD i;
|
|
|
|
for(i=0; i<dwNumAASids; i++)
|
|
{
|
|
// if (EqualSid(psidSAUser, ppsidAAUsers[i]) == TRUE)
|
|
if (psidSAUserLength && psidSAUserLength == ppsidAAUsersLength[i] && !memcmp(psidSAUser, ppsidAAUsers[i], ppsidAAUsersLength[i]))
|
|
return VARIANT_TRUE;
|
|
}
|
|
return VARIANT_FALSE;
|
|
}
|
|
|
|
|
|
HRESULT GetUserList(ISAUserInfo *pSAUserInfo, BSTR **ppbstrSAUserNames,
|
|
VARIANT_BOOL **ppvboolUserTypes, PSID **ppsidSAUsers, LONG **ppsidSAUsersLength, DWORD *pdwNumSAUsers)
|
|
{
|
|
VARIANT_BOOL vboolRes;
|
|
VARIANT vUserNames, vUserTypes, vUserSids;
|
|
SAFEARRAY *psaUserNames, *psaUserTypes, *psaUserSids;
|
|
LONG lNumUsers, lCurrent;
|
|
LONG lStartUserNames, lEndUserNames, lStartUserTypes, lEndUserTypes, lStartUserSids, lEndUserSids;
|
|
HRESULT hr;
|
|
|
|
*pdwNumSAUsers = 0;
|
|
VariantInit(&vUserNames);
|
|
VariantInit(&vUserTypes);
|
|
VariantInit(&vUserSids);
|
|
|
|
hr = pSAUserInfo->GetSAUsers(&vUserNames,
|
|
&vUserTypes,
|
|
&vUserSids,
|
|
VARIANT_TRUE,
|
|
&vboolRes);
|
|
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
psaUserNames = V_ARRAY(&vUserNames);
|
|
psaUserTypes = V_ARRAY(&vUserTypes);
|
|
psaUserSids = V_ARRAY(&vUserSids);
|
|
|
|
_ASSERTE (V_VT(&vUserNames) == (VT_ARRAY | VT_VARIANT));
|
|
if (V_VT(&vUserNames) != (VT_ARRAY | VT_VARIANT))
|
|
return E_INVALIDARG;
|
|
|
|
_ASSERTE(V_VT(&vUserTypes) == (VT_ARRAY | VT_VARIANT));
|
|
if (V_VT(&vUserTypes) != (VT_ARRAY | VT_VARIANT))
|
|
return E_INVALIDARG;
|
|
|
|
_ASSERTE(V_VT(&vUserSids) == (VT_ARRAY | VT_VARIANT));
|
|
if (V_VT(&vUserSids) != (VT_ARRAY | VT_VARIANT))
|
|
return E_INVALIDARG;
|
|
|
|
hr = SafeArrayGetLBound( psaUserNames, 1, &lStartUserNames );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetUBound( psaUserNames, 1, &lEndUserNames );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetLBound( psaUserTypes, 1, &lStartUserTypes );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetUBound( psaUserTypes, 1, &lEndUserTypes );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetLBound( psaUserSids, 1, &lStartUserSids );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetUBound( psaUserSids, 1, &lEndUserSids );
|
|
_ASSERTE(!FAILED(hr));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
_ASSERTE(!( (lStartUserNames != lStartUserTypes) || (lEndUserNames != lEndUserNames) ));
|
|
if ( (lStartUserNames != lStartUserTypes) || (lEndUserNames != lEndUserNames) )
|
|
return E_FAIL;
|
|
|
|
_ASSERTE(!( (lStartUserNames != lStartUserSids) || ((lEndUserNames+2) != lEndUserSids) ));
|
|
if ( (lStartUserNames != lStartUserSids) || ((lEndUserNames+2) != lEndUserSids) )
|
|
return E_FAIL;
|
|
|
|
|
|
lNumUsers = lEndUserNames - lStartUserNames + 1;
|
|
|
|
*pdwNumSAUsers = lNumUsers;
|
|
|
|
*ppbstrSAUserNames = (BSTR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lNumUsers * sizeof(BSTR *));
|
|
_ASSERTE(*ppbstrSAUserNames);
|
|
if ((*ppbstrSAUserNames) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*ppvboolUserTypes = (VARIANT_BOOL *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lNumUsers * sizeof(VARIANT_BOOL));
|
|
_ASSERTE(*ppvboolUserTypes );
|
|
if ((*ppvboolUserTypes ) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*ppsidSAUsers = (PSID *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lNumUsers + 2) * sizeof(PSID));
|
|
_ASSERTE(*ppsidSAUsers );
|
|
if ((*ppsidSAUsers ) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*ppsidSAUsersLength = (LONG *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lNumUsers + 2) * sizeof(LONG));
|
|
_ASSERTE(*ppsidSAUsersLength );
|
|
if ((*ppsidSAUsersLength ) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
VARIANT vName;
|
|
VARIANT vType;
|
|
VARIANT vSid;
|
|
|
|
VariantInit( &vName );
|
|
VariantInit( &vType );
|
|
VariantInit( &vSid );
|
|
|
|
//
|
|
// Process the array elements.
|
|
//
|
|
for ( lCurrent = lStartUserNames; lCurrent <= lEndUserNames; lCurrent++)
|
|
{
|
|
hr = SafeArrayGetElement( psaUserNames, &lCurrent, &vName );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = SafeArrayGetElement( psaUserTypes, &lCurrent, &vType );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = SafeArrayGetElement( psaUserSids, &lCurrent, &vSid );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
_ASSERTE ( V_VT(&vName) == VT_BSTR );
|
|
if ( V_VT(&vName) != VT_BSTR )
|
|
return E_FAIL;
|
|
|
|
_ASSERTE ( V_VT(&vType) == VT_BOOL );
|
|
if ( V_VT(&vType) != VT_BOOL )
|
|
return hr;
|
|
|
|
(*ppbstrSAUserNames)[lCurrent] = SysAllocString(V_BSTR(&vName));
|
|
(*ppvboolUserTypes)[lCurrent] = V_BOOL(&vType);
|
|
hr = UnpackSidFromVariant(&vSid, &(*ppsidSAUsers)[lCurrent], &(*ppsidSAUsersLength)[lCurrent]);
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// _ASSERTE (IsValidSid((*ppsidSAUsers)[lCurrent]));
|
|
// if (IsValidSid((*ppsidSAUsers)[lCurrent]) == FALSE)
|
|
// return E_INVALIDARG;
|
|
|
|
VariantClear( &vName );
|
|
VariantClear( &vType );
|
|
VariantClear( &vSid );
|
|
}
|
|
|
|
// Stash Administrators SID
|
|
lCurrent = lEndUserSids - 1 ;
|
|
|
|
hr = SafeArrayGetElement( psaUserSids, &lCurrent, &vSid );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = UnpackSidFromVariant(&vSid, &g_pSidAdmins, &g_pSidAdminsLenght);
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
VariantClear( &vSid );
|
|
|
|
// Stash Everyone SID
|
|
lCurrent = lEndUserSids;
|
|
|
|
hr = SafeArrayGetElement( psaUserSids, &lCurrent, &vSid );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
hr = UnpackSidFromVariant(&vSid, &g_pSidEverybody, &g_pSidEverybodyLenght);
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
VariantClear( &vSid );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT UnpackSidFromVariant(VARIANT *pvarSid, PSID *ppSid, LONG *plSidLength)
|
|
{
|
|
SAFEARRAY *psaSid;
|
|
LONG lStart = 0L, lEnd = 0L,lCurrent;
|
|
BYTE byteOfSid;
|
|
HRESULT hr;
|
|
|
|
_ASSERTE (V_VT(pvarSid) == (VT_ARRAY | VT_UI1));
|
|
if (V_VT(pvarSid) != (VT_ARRAY | VT_UI1))
|
|
return E_INVALIDARG;
|
|
|
|
psaSid = V_ARRAY(pvarSid);
|
|
|
|
hr = SafeArrayGetLBound( psaSid, 1, &lStart );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = SafeArrayGetUBound( psaSid, 1, &lEnd );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
*plSidLength = lEnd - lStart + 1;
|
|
|
|
*ppSid = (PSID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *plSidLength);
|
|
_ASSERTE(*ppSid);
|
|
if ((*ppSid) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
for(lCurrent = lStart; lCurrent<lEnd; lCurrent++)
|
|
{
|
|
hr = SafeArrayGetElement( psaSid, &lCurrent, &byteOfSid );
|
|
_ASSERTE( !FAILED(hr) );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
((PBYTE)(*ppSid))[lCurrent] = byteOfSid;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT PackSidInVariant(VARIANT **ppVarSid, PSID pSid, LONG lSidLength)
|
|
{
|
|
ULONG i;
|
|
HRESULT hr;
|
|
|
|
_ASSERTE (!((pSid == NULL) || (ppVarSid == NULL)));
|
|
if ((pSid == NULL) || (ppVarSid == NULL))
|
|
return E_INVALIDARG;
|
|
|
|
*ppVarSid = (VARIANT *)HeapAlloc(GetProcessHeap(), 0, sizeof(VARIANT));
|
|
_ASSERTE(*ppVarSid);
|
|
if ((*ppVarSid) == NULL)
|
|
return E_FAIL;
|
|
|
|
VariantInit((*ppVarSid));
|
|
|
|
V_VT((*ppVarSid)) = VT_ARRAY | VT_UI1;
|
|
|
|
SAFEARRAYBOUND bounds;
|
|
bounds.cElements = lSidLength;//GetLengthSid(pSid);
|
|
bounds.lLbound = 0;
|
|
|
|
SAFEARRAY *psaUserSid = NULL;
|
|
|
|
psaUserSid = SafeArrayCreate(VT_UI1, 1, &bounds);
|
|
_ASSERTE(psaUserSid);
|
|
if (psaUserSid == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
for(i=0; i<bounds.cElements; i++)
|
|
{
|
|
hr = SafeArrayPutElement(psaUserSid, (LONG*)&i, (LPVOID)(((unsigned char *)pSid)+i*sizeof(unsigned char)));
|
|
_ASSERTE( !FAILED(hr) );
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
|
|
V_ARRAY((*ppVarSid)) = psaUserSid;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|