windows-nt/Source/XPSP1/NT/ds/adsi/nw312/cuser.cxx

2233 lines
49 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
//---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1996
//
// File: cuser.cxx
//
// Contents: Host user object code
//
// History: Feb-14-96 t-ptam Created.
//
//----------------------------------------------------------------------------
#include "NWCOMPAT.hxx"
#pragma hdrstop
//
// Macro-ized implementation.
//
DEFINE_IDispatch_ExtMgr_Implementation(CNWCOMPATUser)
DEFINE_IADs_TempImplementation(CNWCOMPATUser)
DEFINE_IADs_PutGetImplementation(CNWCOMPATUser, UserClass, gdwUserTableSize)
DEFINE_IADsPropertyList_Implementation(CNWCOMPATUser, UserClass, gdwUserTableSize)
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::CNWCOMPATUser()
//
// Synopsis:
//
//----------------------------------------------------------------------------
CNWCOMPATUser::CNWCOMPATUser():
_pDispMgr(NULL),
_pExtMgr(NULL),
_pPropertyCache(NULL),
_ParentType(0),
_ServerName(NULL),
_szHostServerName(NULL)
{
ENLIST_TRACKING(CNWCOMPATUser);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::CreateUser
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::CreateUser(
BSTR Parent,
ULONG ParentType,
BSTR ServerName,
BSTR UserName,
DWORD dwObjectState,
REFIID riid,
void **ppvObj
)
{
CNWCOMPATUser FAR * pUser = NULL;
HRESULT hr = S_OK;
hr = AllocateUserObject(&pUser);
BAIL_ON_FAILURE(hr);
hr = pUser->InitializeCoreObject(
Parent,
UserName,
USER_CLASS_NAME,
USER_SCHEMA_NAME,
CLSID_NWCOMPATUser,
dwObjectState
);
BAIL_ON_FAILURE(hr);
hr = ADsAllocString( ServerName , &pUser->_ServerName);
BAIL_ON_FAILURE(hr);
hr = ADsAllocString( ServerName, &pUser->_szHostServerName);
BAIL_ON_FAILURE(hr);
hr = pUser->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pUser->Release();
hr = pUser->_pExtMgr->FinalInitializeExtensions();
BAIL_ON_FAILURE(hr);
RRETURN(hr);
error:
delete pUser;
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::~CNWCOMPATUser
//
// Synopsis:
//
//----------------------------------------------------------------------------
CNWCOMPATUser::~CNWCOMPATUser( )
{
ADsFreeString(_ServerName);
ADsFreeString(_szHostServerName);
delete _pExtMgr; // created last, destroyed first
delete _pDispMgr;
delete _pPropertyCache;
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::QueryInterface
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::QueryInterface(
REFIID iid,
LPVOID FAR* ppv
)
{
if (ppv == NULL) {
RRETURN(E_POINTER);
}
if (IsEqualIID(iid, IID_IUnknown))
{
*ppv = (IADsUser FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsUser))
{
*ppv = (IADsUser FAR *) this;
}
else if (IsEqualIID(iid, IID_IADs))
{
*ppv = (IADsUser FAR *) this;
}
else if (IsEqualIID(iid, IID_IDispatch))
{
*ppv = (IADsUser FAR *) this;
}
else if (IsEqualIID(iid, IID_ISupportErrorInfo))
{
*ppv = (ISupportErrorInfo FAR *) this;
}
else if (IsEqualIID(iid, IID_IADsPropertyList))
{
*ppv = (IADsPropertyList FAR *) this;
}
else if (_pExtMgr)
{
RRETURN(_pExtMgr->QueryInterface(iid,ppv));
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
/* ISupportErrorInfo method */
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::InterfaceSupportsErrorInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::InterfaceSupportsErrorInfo(
THIS_ REFIID riid
)
{
if (IsEqualIID(riid, IID_IADs) ||
IsEqualIID(riid, IID_IADsUser) ||
IsEqualIID(riid, IID_IADsPropertyList)) {
RRETURN(S_OK);
} else {
RRETURN(S_FALSE);
}
}
/* IADs methods */
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::SetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::SetInfo(THIS)
{
HRESULT hr = S_OK;
POBJECTINFO pObjectInfo = NULL;
NW_USER_INFO NwUserInfo = {NULL, NULL, NULL, NULL};
//
// Bind an object to a real tangible resource if it is not bounded already.
//
if (GetObjectState() == ADS_OBJECT_UNBOUND) {
hr = BuildObjectInfo(
_Parent,
_Name,
&pObjectInfo
);
BAIL_ON_FAILURE(hr);
hr = NWApiMakeUserInfo(
pObjectInfo->ComponentArray[0],
pObjectInfo->ComponentArray[1],
L"", // empty password initially
&NwUserInfo
);
BAIL_ON_FAILURE(hr);
hr = NWApiCreateUser(
&NwUserInfo
);
BAIL_ON_FAILURE(hr);
SetObjectState(ADS_OBJECT_BOUND);
}
//
// Persist changes.
//
hr = SetInfo(USER_WILD_CARD_ID);
BAIL_ON_FAILURE(hr);
error:
if (pObjectInfo) {
FreeObjectInfo(pObjectInfo);
}
(void) NWApiFreeUserInfo(&NwUserInfo) ;
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::GetInfo(THIS)
{
_pPropertyCache->flushpropcache();
RRETURN(GetInfo(
TRUE,
USER_WILD_CARD_ID
));
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::AllocateUserObject
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::AllocateUserObject(
CNWCOMPATUser ** ppUser
)
{
CNWCOMPATUser FAR * pUser = NULL;
CAggregatorDispMgr FAR * pDispMgr = NULL;
CPropertyCache FAR * pPropertyCache = NULL;
CADsExtMgr FAR * pExtensionMgr = NULL;
HRESULT hr = S_OK;
//
// Allocate memory for a User object.
//
pUser = new CNWCOMPATUser();
if (pUser == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
//
// Create dispatch manager.
//
pDispMgr = new CAggregatorDispMgr;
if (pDispMgr == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
//
// Load type info.
//
hr = LoadTypeInfoEntry(
pDispMgr,
LIBID_ADs,
IID_IADsUser,
(IADsUser *)pUser,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(
pDispMgr,
LIBID_ADs,
IID_IADsPropertyList,
(IADsPropertyList *)pUser,
DISPID_VALUE
);
BAIL_ON_FAILURE(hr);
hr = CPropertyCache::createpropertycache(
UserClass,
gdwUserTableSize,
(CCoreADsObject *)pUser,
&pPropertyCache
);
BAIL_ON_FAILURE(hr);
pDispMgr->RegisterPropertyCache(
pPropertyCache
);
hr = ADSILoadExtensionManager(
USER_CLASS_NAME,
(IADs *) pUser,
pDispMgr,
&pExtensionMgr
);
BAIL_ON_FAILURE(hr);
//
// Return.
//
pUser->_pPropertyCache = pPropertyCache;
pUser->_pDispMgr = pDispMgr;
pUser->_pExtMgr = pExtensionMgr;
*ppUser = pUser;
RRETURN(hr);
error:
delete pDispMgr;
delete pPropertyCache;
delete pUser;
delete pExtensionMgr;
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::SetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::SetInfo(THIS_ DWORD dwPropertyID)
{
HRESULT hr = S_OK;
HRESULT hrTemp = S_OK;
NWCONN_HANDLE hConn = NULL;
//
// Get a handle to the bindery this object resides on.
//
hr = NWApiGetBinderyHandle(
&hConn,
_ServerName
);
BAIL_ON_FAILURE(hr);
//
// Persist changes in cache.
//
hr = SetBusinessInfo(hConn);
BAIL_ON_FAILURE(hr);
hr = SetAccountRestrictions(hConn);
BAIL_ON_FAILURE(hr);
error:
//
// Release handle.
//
if (hConn) {
hrTemp = NWApiReleaseBinderyHandle(hConn);
}
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::SetBusinessInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::SetBusinessInfo(
NWCONN_HANDLE hConn
)
{
LPWSTR lpszRightSize = NULL;
LPWSTR pszFullName = NULL;
CHAR szData[(MAX_FULLNAME_LEN + 1)*2];
HRESULT hr = S_OK;
//
// Set FullName.
//
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("FullName"),
&pszFullName
);
if (SUCCEEDED(hr)) {
//
// Cut the FullName down to no more than MAX_FULLNAME_LEN of characters.
//
lpszRightSize = (LPWSTR) AllocADsMem(
sizeof(WCHAR) * (MAX_FULLNAME_LEN + 1)
);
if (!lpszRightSize) {
RRETURN_EXP_IF_ERR(E_OUTOFMEMORY);
}
lpszRightSize[MAX_FULLNAME_LEN] = 0;
wcsncpy(
lpszRightSize,
pszFullName,
MAX_FULLNAME_LEN
);
//
// Convert bstr in ANSI string.
//
UnicodeToAnsiString(
lpszRightSize,
szData,
0
);
//
// Commit change.
//
hr = NWApiWriteProperty(
hConn,
_Name,
OT_USER,
NW_PROP_IDENTIFICATION,
(LPBYTE) szData
);
BAIL_ON_FAILURE(hr);
FreeADsMem(lpszRightSize);
}
error:
if (pszFullName) {
FreeADsStr(pszFullName);
}
RRETURN(S_OK);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::SetAccountRestrictions
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::SetAccountRestrictions(
NWCONN_HANDLE hConn
)
{
BOOL fModified = FALSE;
DATE daDate = 0;
DWORD dwNumSegment;
HRESULT hr = S_OK;
LC_STRUCTURE LoginCtrl;
LONG lData = 0;
LP_RPLY_SGMT_LST lpReplySegment = NULL;
LP_RPLY_SGMT_LST lpTemp = NULL;
SYSTEMTIME SysTime;
USER_DEFAULT UserDefault;
BOOL fBool;
WORD wDay = 0;
WORD wMonth = 0;
WORD wYear = 0;
WCHAR szTemp[MAX_PATH];
BYTE byDateTime[6];
BOOL fAccntLckModified;
hr = NWApiGetLOGIN_CONTROL(
hConn,
_Name,
&LoginCtrl
);
BAIL_ON_FAILURE(hr);
//
// SET AccountDisabled.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("AccountDisabled"),
&fBool
);
if (SUCCEEDED(hr)) {
LoginCtrl.byAccountDisabled = (BYTE) fBool;
fModified = TRUE;
}
//
// SET AccountExpirationDate.
//
memset(byDateTime, 0, 6);
hr = GetNw312DATEPropertyFromCache(
_pPropertyCache,
TEXT("AccountExpirationDate"),
byDateTime
);
if (SUCCEEDED(hr)) {
LoginCtrl.byAccountExpires[0] = (BYTE) byDateTime[0];
LoginCtrl.byAccountExpires[1] = (BYTE) byDateTime[1];
LoginCtrl.byAccountExpires[2] = (BYTE) byDateTime[2];
fModified = TRUE;
}
//
// SET AccountCanExpire.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("AccountCanExpire"),
&fBool
);
if (SUCCEEDED(hr)) {
if (fBool == FALSE) {
LoginCtrl.byAccountExpires[0] = 0;
LoginCtrl.byAccountExpires[1] = 0;
LoginCtrl.byAccountExpires[2] = 0;
fModified = TRUE;
}
}
//
// SET GraceLoginsAllowed.
//
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("GraceLoginsAllowed"),
(PDWORD)&lData
);
if (SUCCEEDED(hr)) {
LoginCtrl.byGraceLoginReset = (BYTE) lData;
fModified = TRUE;
}
//
// SET GraceLoginsRemaining.
//
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("GraceLoginsRemaining"),
(PDWORD)&lData
);
if (SUCCEEDED(hr)) {
LoginCtrl.byGraceLogins = (BYTE) lData;
fModified = TRUE;
}
//
// SET IsAccountLocked.
//
//
// if this property not modified in cache, no need to set on svr
//
hr = _pPropertyCache->propertyismodified(
TEXT("IsAccountLocked"),
&fAccntLckModified
);
if ( SUCCEEDED(hr) && fAccntLckModified==TRUE ) {
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("IsAccountLocked"),
&fBool
);
if (SUCCEEDED(hr)) {
//
// If fBool is changed from TRUE to FALSE, set wBadLogins
// back to 0 -> this will unlock account on nw svr
//
if (fBool == FALSE) {
LoginCtrl.wBadLogins = 0;
fModified = TRUE;
}else {
//
// Reset it to FALSE if it is changed to TRUE.
// -> cannot lock an account on nwsvr thru' adsi
//
fBool = FALSE;
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("IsAccountLocked"),
fBool,
TRUE
);
BAIL_ON_FAILURE(hr);
}
}
}
//
// SET IsAdmin.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("IsAdmin"),
&fBool
);
if (SUCCEEDED(hr)) {
hr = NWApiUserAsSupervisor(
hConn,
_Name,
fBool
);
//
// For beta, disabling the bail. It does not work in the user not
// supervisor mode.
//
// BAIL_ON_FAILURE(hr);
}
//
// SET MaxLogins.
//
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("MaxLogins"),
(PDWORD)&lData
);
if (SUCCEEDED(hr)) {
LoginCtrl.wMaxConnections = NWApiReverseWORD(
(WORD) lData
);
fModified = TRUE;
}
//
// SET PasswordExpirationDate.
//
memset(byDateTime, 0, 6);
hr = GetNw312DATEPropertyFromCache(
_pPropertyCache,
TEXT("PasswordExpirationDate"),
byDateTime
);
if (SUCCEEDED(hr)) {
LoginCtrl.byPasswordExpires[0] = (BYTE) byDateTime[0];
LoginCtrl.byPasswordExpires[1] = (BYTE) byDateTime[1];
LoginCtrl.byPasswordExpires[2] = (BYTE) byDateTime[2];
fModified = TRUE;
}
//
// SET PasswordCanExpire.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("PasswordCanExpire"),
&fBool
);
if (SUCCEEDED(hr)) {
if (fBool == FALSE) {
//
// If passowrd cannot expire, set password expiration date to zero.
// This is what SysCon does.
//
LoginCtrl.byPasswordExpires[0] = 0;
LoginCtrl.byPasswordExpires[1] = 0;
LoginCtrl.byPasswordExpires[2] = 0;
fModified = TRUE;
}
}
//
// SET PasswordMinimumLength.
//
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("PasswordMinimumLength"),
(PDWORD)&lData
);
if (SUCCEEDED(hr)) {
LoginCtrl.byMinPasswordLength = (BYTE) lData;
fModified = TRUE;
}
//
// SET PasswordRequired. The section below must goes before "Set
// PasswordMinimumLength" for it to make sense.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("PasswordRequired"),
&fBool
);
if (SUCCEEDED(hr)) {
//
// If Password is required, set PasswordMinimumLength to default value.
//
//
// If Password is not required, set PasswordMinimumLength to 0. Again,
// this is what SysCon does.
//
if (fBool) {
if (!LoginCtrl.byMinPasswordLength) {
LoginCtrl.byMinPasswordLength = DEFAULT_MIN_PSWD_LEN;
}
}else{
LoginCtrl.byMinPasswordLength = 0;
}
fModified = TRUE;
}
//
// Set LoginHours
//
OctetString octString;
hr = GetOctetPropertyFromCache(
_pPropertyCache,
TEXT("LoginHours"),
&octString
);
if (SUCCEEDED(hr)) {
memcpy(LoginCtrl.byLoginTimes, octString.pByte, octString.dwSize);
FreeADsMem(octString.pByte);
fModified = TRUE;
}
//
// Set RequireUniquePassword.
//
hr = GetBOOLPropertyFromCache(
_pPropertyCache,
TEXT("RequireUniquePassword"),
&fBool
);
if (SUCCEEDED(hr)) {
LoginCtrl.byRestrictions = fBool ? REQUIRE_UNIQUE_PSWD : 0;
fModified = TRUE;
}
//
// Commit changes of the properties associated with LOGIN_CONTROL.
//
if (fModified == TRUE) {
hr = NWApiWriteProperty(
hConn,
_Name,
OT_USER,
NW_PROP_LOGIN_CONTROL,
(LPBYTE) &LoginCtrl
);
}
else {
hr = S_OK;
}
error:
if (lpReplySegment) {
DELETE_LIST(lpReplySegment);
}
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNWCOMPATUser::GetInfo(
BOOL fExplicit,
DWORD dwPropertyID
)
{
HRESULT hr = S_OK;
HRESULT hrTemp = S_OK;
NWCONN_HANDLE hConn = NULL;
if (GetObjectState() == ADS_OBJECT_UNBOUND) {
RRETURN_EXP_IF_ERR(E_ADS_OBJECT_UNBOUND);
}
//
// Get a handle to the bindery this object resides on.
//
hr = NWApiGetBinderyHandle(
&hConn,
_ServerName
);
BAIL_ON_FAILURE(hr);
//
// Fill in all property caches with values - explicit, or return the
// indicated property - implicit.
//
if (fExplicit) {
hr = ExplicitGetInfo(hConn, fExplicit);
BAIL_ON_FAILURE(hr);
}
else {
hr = ImplicitGetInfo(hConn, dwPropertyID, fExplicit);
BAIL_ON_FAILURE(hr);
}
error:
//
// Release handle.
//
if (hConn) {
hrTemp = NWApiReleaseBinderyHandle(hConn);
}
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::ExplicitGetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::ExplicitGetInfo(
NWCONN_HANDLE hConn,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LC_STRUCTURE LoginCtrlStruct;
//
// Get BusinessInfo functional set.
//
hr = GetProperty_FullName(
hConn,
fExplicit
);
BAIL_ON_FAILURE(hr);
//
// Get LOGIN_CONTROL, which is used in AccountRestriction functional set &
// AccountStatistics functional set.
//
hr = NWApiGetLOGIN_CONTROL(
hConn,
_Name,
&LoginCtrlStruct
);
if (SUCCEEDED(hr)) {
//
// Get AccountRestriction functional set.
//
hr = GetProperty_LoginHours(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_AccountDisabled(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_AccountExpirationDate(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_CanAccountExpire(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_GraceLoginsAllowed(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_GraceLoginsRemaining(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_IsAccountLocked(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_IsAdmin(
hConn,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_MaxLogins(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_CanPasswordExpire(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_PasswordExpirationDate(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_PasswordMinimumLength(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_PasswordRequired(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_RequireUniquePassword(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
//
// Get AccountStatistics functional set.
//
hr = GetProperty_BadLoginAddress(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
hr = GetProperty_LastLogin(
hConn,
LoginCtrlStruct,
fExplicit
);
BAIL_ON_FAILURE(hr);
}
//
// if NWApiGetLOGIN_CONTROL failed, it's okay, we just ignore
// it and don't load those properties into the cache
//
hr = S_OK;
error:
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::ImplicitGetInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::ImplicitGetInfo(
NWCONN_HANDLE hConn,
DWORD dwPropertyID,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
if (dwPropertyID < 100) {
hr = GetBusinessInfo(
hConn,
dwPropertyID,
fExplicit
);
}
else if (dwPropertyID < 200) {
hr = GetAccountRestrictions(
hConn,
dwPropertyID,
fExplicit
);
}
else if (dwPropertyID < 300) {
hr = GetAccountStatistics(
hConn,
dwPropertyID,
fExplicit
);
}
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetBusinessInfo
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetBusinessInfo(
NWCONN_HANDLE hConn,
DWORD dwPropertyID,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
switch (dwPropertyID) {
case USER_FULLNAME_ID:
hr = GetProperty_FullName(
hConn,
fExplicit
);
break;
}
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetAccountRestrictions
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetAccountRestrictions(
NWCONN_HANDLE hConn,
DWORD dwPropertyID,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LC_STRUCTURE LoginCtrlStruct;
//
// Get LOGIN_CONTROL.
//
hr = NWApiGetLOGIN_CONTROL(
hConn,
_Name,
&LoginCtrlStruct
);
if (SUCCEEDED(hr)) {
//
// Get property.
//
switch (dwPropertyID) {
case USER_ACCOUNTDISABLED_ID:
hr = GetProperty_AccountDisabled(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_ACCOUNTEXPIRATIONDATE_ID:
hr = GetProperty_AccountExpirationDate(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_CANACCOUNTEXPIRE_ID:
hr = GetProperty_CanAccountExpire(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_GRACELOGINSALLOWED_ID:
hr = GetProperty_GraceLoginsAllowed(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_GRACELOGINSREMAINING_ID:
hr = GetProperty_GraceLoginsRemaining(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_ISACCOUNTLOCKED_ID:
hr = GetProperty_IsAccountLocked(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_ISADMIN_ID:
hr = GetProperty_IsAdmin(
hConn,
fExplicit
);
break;
case USER_MAXLOGINS_ID:
hr = GetProperty_MaxLogins(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_CANPASSWORDEXPIRE_ID:
hr = GetProperty_CanPasswordExpire(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_PASSWORDEXPIRATIONDATE_ID:
hr = GetProperty_PasswordExpirationDate(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_PASSWORDMINIMUMLENGTH_ID:
hr = GetProperty_PasswordMinimumLength(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_PASSWORDREQUIRED_ID:
hr = GetProperty_PasswordRequired(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_REQUIREUNIQUEPASSWORD_ID:
hr = GetProperty_RequireUniquePassword(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_LOGINHOURS_ID:
hr = GetProperty_LoginHours(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
}
BAIL_ON_FAILURE(hr);
}
//
// if NWApiGetLOGIN_CONTROL failed, it's okay, we just ignore
// it and don't load those properties into the cache
//
hr = S_OK;
error:
RRETURN_EXP_IF_ERR(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetAccountStatistics
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetAccountStatistics(
NWCONN_HANDLE hConn,
DWORD dwPropertyID,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LC_STRUCTURE LoginCtrlStruct;
//
// Get LOGIN_CONTROL.
//
hr = NWApiGetLOGIN_CONTROL(
hConn,
_Name,
&LoginCtrlStruct
);
if (SUCCEEDED(hr)) {
//
// Get property.
//
switch (dwPropertyID) {
case USER_BADLOGINADDRESS_ID:
hr = GetProperty_BadLoginAddress(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
case USER_LASTLOGIN_ID:
hr = GetProperty_LastLogin(
hConn,
LoginCtrlStruct,
fExplicit
);
break;
}
BAIL_ON_FAILURE(hr);
}
//
// if NWApiGetLOGIN_CONTROL failed, it's okay, we just ignore
// it and don't load those properties into the cache
//
hr = S_OK;
error:
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_FullName
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_FullName(
NWCONN_HANDLE hConn,
BOOL fExplicit
)
{
LPWSTR lpszFullName = NULL;
CHAR szFullName[MAX_FULLNAME_LEN + 1];
DWORD dwNumSegment = 0;
HRESULT hr = S_OK;
LP_RPLY_SGMT_LST lpReplySegment = NULL;
LP_RPLY_SGMT_LST lpTemp = NULL; // Used by DELETE_LIST macro below
//
// Get IDENTIFICATIOIN. This property contains the full name of an object.
//
hr = NWApiGetProperty(
_Name,
NW_PROP_IDENTIFICATION,
OT_USER,
hConn,
&lpReplySegment,
&dwNumSegment
);
//
// This call will fail for those users who has never set
// their Fullname, ie. "IDENTIFICATION" is not created. Per Raid #34833
// (resolved By Design), there is no way to distinguish a failure for
// the property not existing from a general failure --- they both return the
// same error code. In general, it is expected that a Bindery user will have
// the IDENTIFICATION property, so if this call fails we assume it was because
// the property didn't exist. In this case, we return success, since it was
// successful, there just didn't happen to be an IDENTIFICATION.
//
if (FAILED(hr)) {
hr = S_OK;
goto error;
}
//
// Convert result into a UNICODE string.
//
strcpy(szFullName, lpReplySegment->Segment);
lpszFullName = (LPWSTR) AllocADsMem(
(strlen(szFullName)+1) * sizeof(WCHAR)
);
if (!lpszFullName)
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
AnsiToUnicodeString(
szFullName,
lpszFullName,
0
);
//
// Unmarshall.
//
hr = SetLPTSTRPropertyInCache(
_pPropertyCache,
TEXT("FullName"),
(LPWSTR)lpszFullName,
fExplicit
);
BAIL_ON_FAILURE(hr);
error:
if (lpszFullName) {
FreeADsMem(lpszFullName);
}
if (lpReplySegment) {
DELETE_LIST(lpReplySegment);
}
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_AccountDisabled
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_AccountDisabled(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Put value into a variant.
//
dwBool = (BOOL) LoginCtrlStruct.byAccountDisabled;
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("AccountDisabled"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_AccountExpirationDate
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_AccountExpirationDate(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
BYTE byDateTime[6];
BYTE byNoDateTime[6];
memset(byNoDateTime, 0, 6);
memset(byDateTime, 0, 6);
memcpy(byDateTime, LoginCtrlStruct.byAccountExpires, 3);
//
// LoginCtrlSturct.byAccountExpires == 000 indicates no expired date
//
if (memcmp(byDateTime, byNoDateTime, 3)!=0) {
hr = SetNw312DATEPropertyInCache(
_pPropertyCache,
TEXT("AccountExpirationDate"),
byDateTime,
fExplicit
);
BAIL_ON_FAILURE(hr);
}
error:
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_CanAccountExpire
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_CanAccountExpire(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Account cannot expire if there is no expiration date.
//
if ((LoginCtrlStruct.byAccountExpires[0] == 0) &&
(LoginCtrlStruct.byAccountExpires[1] == 0) &&
(LoginCtrlStruct.byAccountExpires[2] == 0)) {
dwBool = FALSE;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("AccountCanExpire"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_GraceLoginsAllowed
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_GraceLoginsAllowed(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LONG lGraceLoginsAllowed = 0;
//
// Get "byGraceLoginReset". The property is not meaningful when it equals
// to 0xff.
//
if (LoginCtrlStruct.byGraceLoginReset != 0xff) {
lGraceLoginsAllowed = (LONG) LoginCtrlStruct.byGraceLoginReset;
}
//
// Unmarshall.
//
hr = SetDWORDPropertyInCache(
_pPropertyCache,
TEXT("GraceLoginsAllowed"),
(DWORD)lGraceLoginsAllowed,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_GraceLoginsRemaining
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_GraceLoginsRemaining(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LONG lGraceLoginsRemaining = 0;
//
// Get "byGraceLogins". The property is not meaningful when it equals to
// 0xff.
//
if (LoginCtrlStruct.byGraceLogins != 0xff) {
lGraceLoginsRemaining = (LONG) LoginCtrlStruct.byGraceLogins;
}
//
// Unmarshall.
//
hr = SetDWORDPropertyInCache(
_pPropertyCache,
TEXT("GraceLoginsRemaining"),
(DWORD)lGraceLoginsRemaining,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_IsAccountLocked
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_IsAccountLocked(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = FALSE;
HRESULT hr = S_OK;
//
// Account is locked when wBadLogins = 0xffff.
//
if (LoginCtrlStruct.wBadLogins == 0xffff) {
dwBool = TRUE;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("IsAccountLocked"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_IsAdmin
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_IsAdmin(
NWCONN_HANDLE hConn,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Check if this user has the same security as the supervisor. If it does,
// then it is an admin.
//
hr = NWApiIsObjectInSet(
hConn,
_Name,
OT_USER,
NW_PROP_SECURITY_EQUALS,
NW_PROP_SUPERVISOR,
OT_USER
);
// Per bug #33322 (resolved By Design), there is no way to distinguish
// "no such object" from a general failure. So we assume that any failure
// is "no such object".
if (FAILED(hr)) {
dwBool = FALSE;
hr = S_OK;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("IsAdmin"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_MaxLogins
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_MaxLogins(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LONG lMaxLogins = 0;
//
// Get "wMaxConnections".
//
lMaxLogins = (LONG) NWApiReverseWORD(
LoginCtrlStruct.wMaxConnections
);
//
// Unmarshall.
//
hr = SetDWORDPropertyInCache(
_pPropertyCache,
TEXT("MaxLogins"),
(DWORD)lMaxLogins,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_CanPasswordExpire
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_CanPasswordExpire(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Password cannot expire if there is no expiration date.
//
if ((LoginCtrlStruct.byPasswordExpires[0] == 0) &&
(LoginCtrlStruct.byPasswordExpires[1] == 0) &&
(LoginCtrlStruct.byPasswordExpires[2] == 0)) {
dwBool = FALSE;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("PasswordCanExpire"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_PasswordExpirationDate
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_PasswordExpirationDate(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
BYTE byDateTime[6];
memset(byDateTime, 0, 6);
memcpy(byDateTime, LoginCtrlStruct.byPasswordExpires, 3);
hr = SetNw312DATEPropertyInCache(
_pPropertyCache,
TEXT("PasswordExpirationDate"),
byDateTime,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_PasswordMinimumLength
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_PasswordMinimumLength(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LONG lMinimumLength = 0;
//
// Get "byMinPasswordLength".
//
lMinimumLength = (LONG) LoginCtrlStruct.byMinPasswordLength;
//
// Unmarshall.
//
hr = SetDWORDPropertyInCache(
_pPropertyCache,
TEXT("PasswordMinimumLength"),
(DWORD)lMinimumLength,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_PasswordRequired
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_PasswordRequired(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Password is not required if "byMinPasswordLength" is 0.
//
if (LoginCtrlStruct.byMinPasswordLength == 0) {
dwBool = FALSE;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("PasswordRequired"),
dwBool,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_RequireUniquePassword
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_RequireUniquePassword(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// If byRestrictions = 0, "RequireUniquePassword" = FALSE.
//
if (LoginCtrlStruct.byRestrictions == 0) {
dwBool = FALSE;
}
//
// Unmarshall.
//
hr = SetBOOLPropertyInCache(
_pPropertyCache,
TEXT("RequireUniquePassword"),
dwBool,
fExplicit
);
RRETURN(hr);
}
HRESULT
CNWCOMPATUser::GetProperty_LoginHours(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
BOOL dwBool = TRUE;
HRESULT hr = S_OK;
//
// Unmarshall.
//
hr = SetOctetPropertyInCache(
_pPropertyCache,
TEXT("LoginHours"),
(BYTE*)LoginCtrlStruct.byLoginTimes,
24,
fExplicit
);
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_BadLoginAddress
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_BadLoginAddress(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
LPWSTR lpszTemp = NULL;
//
// Put address together in the format described in spec.
//
lpszTemp = (LPWSTR) AllocADsMem((NET_ADDRESS_NUM_CHAR+1)*sizeof(WCHAR));
if (!lpszTemp) {
RRETURN(E_OUTOFMEMORY);
}
wsprintf(
lpszTemp,
L"%s:%02X%02X%02X%02X.%02X%02X%02X%02X%02X%02X.%02X%02X",
bstrAddressTypeString,
LoginCtrlStruct.byBadLoginAddr[10],
LoginCtrlStruct.byBadLoginAddr[11],
LoginCtrlStruct.byBadLoginAddr[0],
LoginCtrlStruct.byBadLoginAddr[1],
LoginCtrlStruct.byBadLoginAddr[2],
LoginCtrlStruct.byBadLoginAddr[3],
LoginCtrlStruct.byBadLoginAddr[4],
LoginCtrlStruct.byBadLoginAddr[5],
LoginCtrlStruct.byBadLoginAddr[6],
LoginCtrlStruct.byBadLoginAddr[7],
LoginCtrlStruct.byBadLoginAddr[8],
LoginCtrlStruct.byBadLoginAddr[9]
);
//
// Unmarshall.
//
hr = SetLPTSTRPropertyInCache(
_pPropertyCache,
TEXT("BadLoginAddress"),
(LPWSTR)lpszTemp,
fExplicit
);
BAIL_ON_FAILURE(hr);
error:
if (lpszTemp) {
FreeADsMem(lpszTemp);
}
RRETURN(hr);
}
//----------------------------------------------------------------------------
//
// Function: CNWCOMPATUser::GetProperty_LastLogin
//
// Synopsis:
//
//----------------------------------------------------------------------------
HRESULT
CNWCOMPATUser::GetProperty_LastLogin(
NWCONN_HANDLE hConn,
LC_STRUCTURE LoginCtrlStruct,
BOOL fExplicit
)
{
HRESULT hr = S_OK;
BYTE byNoDateTime[6];
memset(byNoDateTime, 0, 6);
//
// LastLogin==000000 indicates no or unknown LastLogin
//
if (memcmp(LoginCtrlStruct.byLastLogin, byNoDateTime, 6) != 0) {
hr = SetNw312DATEPropertyInCache(
_pPropertyCache,
TEXT("LastLogin"),
LoginCtrlStruct.byLastLogin,
fExplicit
);
}
RRETURN(hr);
}
HRESULT
ConvertNW312DateToVariant(
BYTE byDateTime[],
PDATE pDate
)
{
HRESULT hr = S_OK;
WORD wYear;
//
// Subtract 80 from wYear for NWApiMakeVariantTime.
//
wYear = (WORD)byDateTime[0];
if (wYear != 0) {
wYear -= 80;
}
//
// Convert into Variant Time.
//
hr = NWApiMakeVariantTime(
pDate,
(WORD)byDateTime[2],
(WORD)byDateTime[1],
wYear,
0,0,0
);
RRETURN(hr);
}
HRESULT
ConvertVariantToNW312Date(
DATE daDate,
BYTE byDateTime[]
)
{
WORD wDay;
WORD wYear;
WORD wMonth;
HRESULT hr = S_OK;
hr = NWApiBreakVariantTime(
daDate,
&wDay,
&wMonth,
&wYear
);
BAIL_ON_FAILURE(hr);
byDateTime[0] = (BYTE)wYear;
byDateTime[1] = (BYTE)wMonth;
byDateTime[2] = (BYTE)wDay;
byDateTime[3] = 0;
byDateTime[4] = 0;
byDateTime[5] = 0;
error:
RRETURN(hr);
}