/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
rnduser.cpp
Abstract:
This module contains implementation of CUser object.
Author:
Rajeevb,
Modification history:
Mu Han (muhan) 12-5-1997
--*/
#include "stdafx.h"
#include "rnduser.h"
const WCHAR * const UserAttributeNames[] =
{
L"SamAccountName", // ZoltanS: was "cn" -- we need SamAccountName for ntds.
L"telephoneNumber",
L"IPPhone"
};
#define INC_ACCESS_ACL_SIZE(_SIZE_, _SID_) \
_SIZE_ += (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(_SID_));
#define BAIL_ON_BOOLFAIL(_FN_) \
if ( !_FN_ ) \
{ \
hr = HRESULT_FROM_WIN32(GetLastError()); \
goto failed; \
}
#define ACCESS_READ 0x10
#define ACCESS_WRITE 0x20
#define ACCESS_MODIFY (ACCESS_WRITE | WRITE_DAC)
#define ACCESS_DELETE DELETE
#define ACCESS_ALL (ACCESS_READ | ACCESS_MODIFY | ACCESS_DELETE)
HRESULT
ConvertStringToSid(
IN PWSTR string,
OUT PSID *sid,
OUT PDWORD pdwSidSize,
OUT PWSTR *end
);
HRESULT
ConvertACLToVariant(
PACL pACL,
LPVARIANT pvarACL
);
/////////////////////////////////////////////////////////////////////////////
// non-interface class methods
/////////////////////////////////////////////////////////////////////////////
HRESULT CUser::Init(BSTR bName)
{
HRESULT hr;
hr = SetSingleValue(UA_USERNAME, bName);
BAIL_IF_FAIL(hr, "can't set user name");
hr = SetDefaultSD();
BAIL_IF_FAIL(hr, "Init the security descriptor");
return hr;
}
HRESULT
CUser::GetSingleValueBstr(
IN OBJECT_ATTRIBUTE Attribute,
OUT BSTR * AttributeValue
)
{
LOG((MSP_INFO, "CUser::GetSingleValueBstr - entered"));
BAIL_IF_BAD_WRITE_PTR(AttributeValue, E_POINTER);
if (!ValidUserAttribute(Attribute))
{
LOG((MSP_ERROR, "Invalid Attribute, %d", Attribute));
return E_FAIL;
}
CLock Lock(m_lock);
if(!m_Attributes[UserAttrIndex(Attribute)])
{
LOG((MSP_ERROR, "Attribute %S is not found",
UserAttributeName(Attribute)));
return E_FAIL;
}
*AttributeValue = SysAllocString(m_Attributes[UserAttrIndex(Attribute)]);
if (*AttributeValue == NULL)
{
return E_OUTOFMEMORY;
}
LOG((MSP_INFO, "CUser::get %S: %S",
UserAttributeName(Attribute), *AttributeValue));
return S_OK;
}
HRESULT
CUser::SetSingleValue(
IN OBJECT_ATTRIBUTE Attribute,
IN WCHAR * AttributeValue
)
{
LOG((MSP_INFO, "CUser::SetSingleValue - entered"));
if (!ValidUserAttribute(Attribute))
{
LOG((MSP_ERROR, "Invalid Attribute, %d", Attribute));
return E_FAIL;
}
if (AttributeValue != NULL)
{
BAIL_IF_BAD_READ_PTR(AttributeValue, E_POINTER);
}
CLock Lock(m_lock);
if (!m_Attributes[UserAttrIndex(Attribute)].set(AttributeValue))
{
LOG((MSP_ERROR, "Can not add attribute %S",
UserAttributeName(Attribute)));
return E_OUTOFMEMORY;
}
LOG((MSP_INFO, "CUser::set %S to %S",
UserAttributeName(Attribute), AttributeValue));
return S_OK;
}
/*++
Routine Description:
Set the right security descriptor for the conference.
Arguments:
Return Value:
HRESULT.
--*/
HRESULT
CUser::SetDefaultSD()
{
LOG((MSP_INFO, "CConference::SetDefaultSD - entered"));
//
// The security descriptor
//
IADsSecurityDescriptor* pSecDesc = NULL;
HRESULT hr = S_OK;
bool bOwner = false, bWorld = false;
PACL pACL = NULL;
PSID pSidWorld = NULL;
DWORD dwAclSize = sizeof(ACL), dwTemp;
BSTR bstrTemp = NULL;
LPWSTR pszTemp = NULL;
HANDLE hToken;
UCHAR *pInfoBuffer = NULL;
DWORD cbInfoBuffer = 512;
//
// Try to get the thread or process token
//
if( !OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &hToken) )
{
//
// If there was a sever error we exit
//
if( GetLastError() != ERROR_NO_TOKEN )
{
LOG((MSP_ERROR, "CConference::SetDefaultSD - exit E_FAIL "
"OpenThreadToken failed!"));
return E_FAIL;
}
//
// Attempt to open the process token, since no thread token exists
//
if( !OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken) )
{
LOG((MSP_ERROR, "CConference::SetDefaultSD - exit E_FAIL "
"OpenProcessToken failed"));
return E_FAIL;
}
}
//
// Loop until we have a large enough structure
//
while ( (pInfoBuffer = new UCHAR[cbInfoBuffer]) != NULL )
{
if ( !GetTokenInformation(hToken, TokenUser, pInfoBuffer, cbInfoBuffer, &cbInfoBuffer) )
{
delete pInfoBuffer;
pInfoBuffer = NULL;
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
return E_FAIL;
}
else
{
break;
}
}
CloseHandle(hToken);
//
// Did we get the owner ACL?
//
if ( pInfoBuffer )
{
INC_ACCESS_ACL_SIZE( dwAclSize, ((PTOKEN_USER) pInfoBuffer)->User.Sid );
bOwner = true;
}
//
// Make SID for "Everyone"
//
SysReAllocString( &bstrTemp, L"S-1-1-0" );
hr = ConvertStringToSid( bstrTemp, &pSidWorld, &dwTemp, &pszTemp );
if ( SUCCEEDED(hr) )
{
INC_ACCESS_ACL_SIZE( dwAclSize, pSidWorld );
bWorld = true;
}
//
// Create a security descriptor
//
hr = CoCreateInstance(
CLSID_SecurityDescriptor,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsSecurityDescriptor,
(void **)&pSecDesc
);
if( FAILED(hr) )
{
LOG((MSP_ERROR, "CConference::SetDefaultSD - exit 0x%08x "
"Create security descriptor failed!", hr));
goto failed;
}
//
// Create the ACL containing the Owner and World ACEs
//
pACL = (PACL) new BYTE[dwAclSize];
if ( pACL )
{
BAIL_ON_BOOLFAIL( InitializeAcl(pACL, dwAclSize, ACL_REVISION) );
// Add World Rights
if ( bWorld )
{
if ( bOwner )
{
BAIL_ON_BOOLFAIL( AddAccessAllowedAce(pACL, ACL_REVISION, ACCESS_READ, pSidWorld) );
}
else
{
BAIL_ON_BOOLFAIL( AddAccessAllowedAce(pACL, ACL_REVISION, ACCESS_ALL , pSidWorld) );
}
}
// Add Creator rights
if ( bOwner )
BAIL_ON_BOOLFAIL( AddAccessAllowedAce(pACL, ACL_REVISION, ACCESS_ALL, ((PTOKEN_USER) pInfoBuffer)->User.Sid) );
// Set the DACL onto our security descriptor
VARIANT varDACL;
VariantInit( &varDACL );
if ( SUCCEEDED(hr = ConvertACLToVariant((PACL) pACL, &varDACL)) )
{
if ( SUCCEEDED(hr = pSecDesc->put_DaclDefaulted(FALSE)) )
{
hr = pSecDesc->put_DiscretionaryAcl( V_DISPATCH(&varDACL) );
if( SUCCEEDED(hr) )
{
hr = put_SecurityDescriptor((IDispatch*)pSecDesc);
if( SUCCEEDED(hr) )
{
hr = this->put_SecurityDescriptorIsModified(TRUE);
}
}
}
}
VariantClear( &varDACL );
}
else
{
hr = E_OUTOFMEMORY;
}
// Clean up
failed:
SysFreeString( bstrTemp );
if ( pACL ) delete pACL;
if ( pSidWorld ) delete pSidWorld;
if ( pInfoBuffer ) delete pInfoBuffer;
if( pSecDesc ) pSecDesc->Release();
LOG((MSP_INFO, "CConference::SetDefaultSD - exit 0x%08x", hr));
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// ITDirectoryObject
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CUser::get_Name(BSTR * ppVal)
{
return GetSingleValueBstr(UA_USERNAME, ppVal);
}
STDMETHODIMP CUser::put_Name(BSTR pVal)
{
return SetSingleValue(UA_USERNAME, pVal);
}
STDMETHODIMP CUser::get_DialableAddrs(
IN long dwAddressTypes, //defined in tapi.h
OUT VARIANT * pVariant
)
{
BAIL_IF_BAD_WRITE_PTR(pVariant, E_POINTER);
HRESULT hr;
BSTR *Addresses = new BSTR[1]; // only one for now.
BAIL_IF_NULL(Addresses, E_OUTOFMEMORY);
switch (dwAddressTypes)
{
case LINEADDRESSTYPE_DOMAINNAME:
hr = GetSingleValueBstr(UA_IPPHONE_PRIMARY, &Addresses[0]);
break;
case LINEADDRESSTYPE_IPADDRESS:
{
BSTR pDomainName;
DWORD dwIP;
hr = GetSingleValueBstr(UA_IPPHONE_PRIMARY, &pDomainName);
if ( SUCCEEDED(hr) )
{
hr = ResolveHostName(0, pDomainName, NULL, &dwIP);
SysFreeString(pDomainName);
if ( SUCCEEDED(hr) )
{
WCHAR wszIP[20];
ipAddressToStringW(wszIP, dwIP);
Addresses[0] = SysAllocString(wszIP);
if ( Addresses[0] == NULL )
{
hr = E_OUTOFMEMORY;
}
}
}
}
break;
case LINEADDRESSTYPE_PHONENUMBER:
hr = GetSingleValueBstr(UA_TELEPHONE_NUMBER, &Addresses[0]);
break;
default:
hr = E_FAIL;
break;
}
DWORD dwCount = (FAILED(hr)) ? 0 : 1;
hr = ::CreateBstrCollection(dwCount, // count
&Addresses[0], // begin pointer
&Addresses[dwCount], // end pointer
pVariant, // return value
AtlFlagTakeOwnership); // flags
// the collection will destroy the Addresses array eventually.
// no need to free anything here. Even if we tell it to hand
// out zero objects, it will delete the array on construction.
// (ZoltanS verified.)
return hr;
}
STDMETHODIMP CUser::EnumerateDialableAddrs(
IN DWORD dwAddressTypes, //defined in tapi.h
OUT IEnumDialableAddrs ** ppEnumDialableAddrs
)
{
BAIL_IF_BAD_WRITE_PTR(ppEnumDialableAddrs, E_POINTER);
HRESULT hr;
BSTR *Addresses = new BSTR[1]; // only one for now.
BAIL_IF_NULL(Addresses, E_OUTOFMEMORY);
switch (dwAddressTypes)
{
case LINEADDRESSTYPE_IPADDRESS:
{
BSTR pDomainName;
DWORD dwIP;
hr = GetSingleValueBstr(UA_IPPHONE_PRIMARY, &pDomainName);
if ( SUCCEEDED(hr) )
{
hr = ResolveHostName(0, pDomainName, NULL, &dwIP);
SysFreeString(pDomainName);
if ( SUCCEEDED(hr) )
{
WCHAR wszIP[20];
ipAddressToStringW(wszIP, dwIP);
Addresses[0] = SysAllocString(wszIP);
if ( Addresses[0] == NULL )
{
hr = E_OUTOFMEMORY;
}
}
}
}
break;
case LINEADDRESSTYPE_DOMAINNAME:
hr = GetSingleValueBstr(UA_IPPHONE_PRIMARY, &Addresses[0]);
break;
case LINEADDRESSTYPE_PHONENUMBER:
hr = GetSingleValueBstr(UA_TELEPHONE_NUMBER, &Addresses[0]);
break;
default:
hr = E_FAIL;
break;
}
DWORD dwCount = (FAILED(hr)) ? 0 : 1;
hr = ::CreateDialableAddressEnumerator(
&Addresses[0],
&Addresses[dwCount],
ppEnumDialableAddrs
);
// the enumerator will destroy the Addresses array eventually,
// so no need to free anything here. Even if we tell it to hand
// out zero objects, it will delete the array on destruction.
// (ZoltanS verified.)
return hr;
}
STDMETHODIMP CUser::GetAttribute(
IN OBJECT_ATTRIBUTE Attribute,
OUT BSTR * ppAttributeValue
)
{
return GetSingleValueBstr(Attribute, ppAttributeValue);
}
STDMETHODIMP CUser::SetAttribute(
IN OBJECT_ATTRIBUTE Attribute,
IN BSTR pAttributeValue
)
{
return SetSingleValue(Attribute, pAttributeValue);
}
STDMETHODIMP CUser::GetTTL(
OUT DWORD * pdwTTL
)
{
BAIL_IF_BAD_WRITE_PTR(pdwTTL, E_POINTER);
*pdwTTL = 0;
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// ITDirectoryObjectUser
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CUser::get_IPPhonePrimary(
OUT BSTR *pVal
)
{
return GetSingleValueBstr(UA_IPPHONE_PRIMARY, pVal);
}
STDMETHODIMP CUser::put_IPPhonePrimary(
IN BSTR newVal
)
{
// ZoltanS: we now need to check the BSTR, as the ResolveHostName
// call below doesn't check it before using it.
// Second argument is the maximum length of string to check -- we want
// to check the whole thing, so we say (UINT) -1, which is about 2^32.
if ( IsBadStringPtr(newVal, (UINT) -1) )
{
LOG((MSP_ERROR, "CUser::put_IPPhonePrimary: bad BSTR"));
return E_POINTER;
}
// ZoltanS: We shouldn't let the user set an IPPhonePrimary value that
// doesn't resolve to a known host / IP. Check here.
char * pchFullDNSName = NULL; // we don't really care what we get
DWORD dwIp = 0; // we don't really care what we get
// This is our utility function from rndutil.cpp.
HRESULT hr = ResolveHostName(0, newVal, &pchFullDNSName, &dwIp);
if (FAILED(hr))
{
LOG((MSP_ERROR, "CUser::put_IPPhonePrimary: unresolvable name"));
return hr;
}
// Now actually set it.
return SetSingleValue(UA_IPPHONE_PRIMARY, newVal);
}
typedef IDispatchImpl<ITDirectoryObjectUserVtbl<CUser>, &IID_ITDirectoryObjectUser, &LIBID_RENDLib> CTDirObjUser;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// CUser::GetIDsOfNames
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
STDMETHODIMP CUser::GetIDsOfNames(REFIID riid,
LPOLESTR* rgszNames,
UINT cNames,
LCID lcid,
DISPID* rgdispid
)
{
LOG((MSP_TRACE, "CUser::GetIDsOfNames[%p] - enter. Name [%S]",this, *rgszNames));
HRESULT hr = DISP_E_UNKNOWNNAME;
//
// See if the requsted method belongs to the default interface
//
hr = CTDirObjUser::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
if (SUCCEEDED(hr))
{
LOG((MSP_TRACE, "CUser::GetIDsOfNames - found %S on CTDirObjUser", *rgszNames));
rgdispid[0] |= IDISPDIROBJUSER;
return hr;
}
//
// If not, then try the CDirectoryObject base class
//
hr = CDirectoryObject::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
if (SUCCEEDED(hr))
{
LOG((MSP_TRACE, "CUser::GetIDsOfNames - found %S on CDirectoryObject", *rgszNames));
rgdispid[0] |= IDISPDIROBJECT;
return hr;
}
LOG((MSP_ERROR, "CUser::GetIDsOfNames[%p] - finish. didn't find %S on our iterfaces",*rgszNames));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// CUser::Invoke
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
STDMETHODIMP CUser::Invoke(DISPID dispidMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS* pdispparams,
VARIANT* pvarResult,
EXCEPINFO* pexcepinfo,
UINT* puArgErr
)
{
LOG((MSP_TRACE, "CUser::Invoke[%p] - enter. dispidMember %lx",this, dispidMember));
HRESULT hr = DISP_E_MEMBERNOTFOUND;
DWORD dwInterface = (dispidMember & INTERFACEMASK);
//
// Call invoke for the required interface
//
switch (dwInterface)
{
case IDISPDIROBJUSER:
{
hr = CTDirObjUser::Invoke(dispidMember,
riid,
lcid,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr
);
LOG((MSP_TRACE, "CUser::Invoke - ITDirectoryObjectUser"));
break;
}
case IDISPDIROBJECT:
{
hr = CDirectoryObject::Invoke(dispidMember,
riid,
lcid,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr
);
LOG((MSP_TRACE, "CUser::Invoke - ITDirectoryObject"));
break;
}
} // end switch (dwInterface)
LOG((MSP_TRACE, "CUser::Invoke[%p] - finish. hr = %lx", hr));
return hr;
}