2233 lines
51 KiB
C++
2233 lines
51 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// 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);
|
|
}
|