able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tapi/skywalker/rend/rndcnf.cpp

1436 lines
34 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997-2000 Microsoft Corporation
Module Name:
rndcnf.cpp
Abstract:
This module contains implementation of CConference object.
--*/
#include "stdafx.h"
#include <winsock2.h>
#include "rndcnf.h"
// These are the attribute names according to the schema in NTDS.
const WCHAR *const MeetingAttributeNames[] =
{
L"meetingAdvertisingScope",
L"meetingBlob",
L"meetingDescription",
L"meetingIsEncrypted",
L"meetingName",
L"meetingOriginator",
L"meetingProtocol",
L"meetingStartTime",
L"meetingStopTime",
L"meetingType",
L"meetingURL"
};
#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
CConference::FinalConstruct()
/*++
Routine Description:
Create the SDPBlob object that is aggregated with the conference object.
Also query my own Notification interface which will be given to the
SDPBlob object. To avoid circlar ref count, this interface is realeased
as soon as it is queried.
Arguments:
Return Value:
HRESULT.
--*/
{
// Create the conference Blob
CComPtr <IUnknown> pIUnkConfBlob;
HRESULT hr = CoCreateInstance(
CLSID_SdpConferenceBlob,
NULL,
CLSCTX_INPROC_SERVER,
IID_IUnknown,
(void **)&pIUnkConfBlob
);
BAIL_IF_FAIL(hr, "Create SdpConferenceBlob");
// Get the ITConfBlobPrivate interface from the Blob object.
CComPtr <ITConfBlobPrivate> pITConfBlobPrivate;
hr = pIUnkConfBlob->QueryInterface(
IID_ITConfBlobPrivate,
(void **)&pITConfBlobPrivate
);
BAIL_IF_FAIL(hr, "Query ITConfBlobPrivate interface");
// query the conf blob instance for the conf blob i/f
CComPtr <ITConferenceBlob> pITConfBlob;
hr = pIUnkConfBlob->QueryInterface(
IID_ITConferenceBlob,
(void **)&pITConfBlob
);
BAIL_IF_FAIL(hr, "Query ITConferenceBlob");
// keep the interface pointers.
m_pIUnkConfBlob = pIUnkConfBlob;
m_pIUnkConfBlob->AddRef();
m_pITConfBlob = pITConfBlob;
m_pITConfBlob->AddRef();
m_pITConfBlobPrivate = pITConfBlobPrivate;
m_pITConfBlobPrivate->AddRef();
return S_OK;
}
HRESULT CConference::Init(BSTR bName)
/*++
Routine Description:
Init this conference with only a name. This is called when an empty
conference is created. A default SDP blob will be created. The format
is in the registry. See sdpblb code.
Arguments:
bName - The name of the conference.
Return Value:
HRESULT.
--*/
{
HRESULT hr;
hr = SetDefaultValue(
g_ConfInstInfoArray,
g_ContInstInfoArraySize
);
BAIL_IF_FAIL(hr, "set default attribute value");
hr = SetSingleValue(MA_MEETINGNAME, bName);
BAIL_IF_FAIL(hr, "can't set meeting name");
hr = m_pITConfBlob->Init(bName, BCS_UTF8, NULL);
BAIL_IF_FAIL(hr, "Init the conference Blob");
hr = SetDefaultSD();
BAIL_IF_FAIL(hr, "Init the security descriptor");
return hr;
}
HRESULT CConference::Init(BSTR bName, BSTR bProtocol, BSTR bBlob)
/*++
Routine Description:
Init this conference with only the conference name and also a conference
blob whose protocol should be IP conference. The blob is parsed by the
SDP Blob object and the information in the blob will be notified back
to this conference object through the notification interface.
Arguments:
bName - The name of the conference.
bProtocol - The protocol used by the blob. should be SDP now.
bBlob - The opaque data blob that describes this conference.
Return Value:
HRESULT.
--*/
{
HRESULT hr;
hr = SetSingleValue(MA_MEETINGNAME, bName);
BAIL_IF_FAIL(hr, "can't set meeting name");
// Check to make sure protocol is IP Conference
if ( wcscmp(bProtocol, L"IP Conference" ))
{
LOG((MSP_ERROR, "Protocol must be IP Conference"));
return E_INVALIDARG;
}
hr = SetSingleValue(MA_PROTOCOL, bProtocol);
BAIL_IF_FAIL(hr, "can't set meeting protocol");
hr = SetSingleValue(MA_CONFERENCE_BLOB, bBlob);
BAIL_IF_FAIL(hr, "can't set meeting blob");
hr = m_pITConfBlob->Init(NULL, BCS_UTF8, bBlob);
BAIL_IF_FAIL(hr, "Init the conference Blob object");
return hr;
}
void
CConference::FinalRelease()
/*++
Routine Description:
Clean up the SDP blob contained in this object.
clean up the security object for this object.
clean up all the attributes.
Arguments:
Return Value:
--*/
{
CLock Lock(m_lock);
// do base class first
CDirectoryObject::FinalRelease();
if ( NULL != m_pIUnkConfBlob )
{
m_pIUnkConfBlob->Release();
m_pIUnkConfBlob = NULL;
}
if ( NULL != m_pITConfBlobPrivate )
{
m_pITConfBlobPrivate->Release();
m_pITConfBlobPrivate = NULL;
}
if ( NULL != m_pITConfBlob )
{
m_pITConfBlob->Release();
m_pITConfBlob = NULL;
}
// MuHan + ZoltanS fix 3-19-98 -- these are member smart pointers,
// should not be deleted!!!
// for (DWORD i = 0; i < NUM_MEETING_ATTRIBUTES; i ++)
// {
// delete m_Attributes[i];
// }
// the interface pointer to this instance's ITNotification i/f is NOT
// released because it was already released in FinalConstruct but the
// pointer was held to be passed onto the aggregated conf blob instance
}
HRESULT
CConference::UpdateConferenceBlob(
IN IUnknown *pIUnkConfBlob
)
/*++
Routine Description:
update the blob attribute if the blob object has been changed.
Arguments:
pIUnkConfBlob - pointer to the SDPBlob object.
Return Value:
HRESULT.
--*/
{
// check if the sdp blob has been modified since the component was created
VARIANT_BOOL BlobIsModified;
BAIL_IF_FAIL(m_pITConfBlobPrivate->get_IsModified(&BlobIsModified),
"UpdateConferenceBlob.get_IsModified");
// if not, return
if ( BlobIsModified == VARIANT_FALSE )
{
return S_OK;
}
// get the blob and
CBstr SdpBlobBstr;
BAIL_IF_FAIL(m_pITConfBlob->get_ConferenceBlob(&SdpBlobBstr),
"UpdateConferenceBlob.get_ConfrenceBlob");
// set the conference blob attribute for the conference
BAIL_IF_FAIL(SetSingleValue(MA_CONFERENCE_BLOB, SdpBlobBstr),
"UpdateConferenceBlob.Setblob");
return S_OK;
}
HRESULT
CConference::SetDefaultValue(
IN REG_INFO RegInfo[],
IN DWORD dwItems
)
/*++
Routine Description:
Set attributes to the default value got from the registry.
Arguments:
RegInfo - {attribute, value} array.
dwItems - The number of items in the array.
Return Value:
HRESULT.
--*/
{
for (DWORD i=0; i < dwItems ; i++)
{
HRESULT hr;
hr = SetSingleValue(RegInfo[i].Attribute, RegInfo[i].wstrValue);
BAIL_IF_FAIL(hr, "set value");
}
return S_OK;
}
/*++
Routine Description:
Set the right security descriptor for the conference.
Arguments:
Return Value:
HRESULT.
--*/
HRESULT
CConference::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;
}
HRESULT
CConference::GetSingleValueBstr(
IN OBJECT_ATTRIBUTE Attribute,
OUT BSTR * AttributeValue
)
/*++
Routine Description:
Get the value of an attribute and create a BSTR to return.
Arguments:
Attribute - the attribute id as defined in rend.idl
AttributeValue - a pointer to a BSTR that points to the returned value.
Return Value:
HRESULT.
--*/
{
LOG((MSP_INFO, "CConference::GetSingleValueBstr - entered"));
BAIL_IF_BAD_WRITE_PTR(AttributeValue, E_POINTER);
// Check to see if the attribute is valid.
if (!ValidMeetingAttribute(Attribute))
{
LOG((MSP_ERROR, "Invalid Attribute, %d", Attribute));
return E_FAIL;
}
CLock Lock(m_lock);
// check to see if I have this attribute.
if(!m_Attributes[MeetingAttrIndex(Attribute)])
{
LOG((MSP_ERROR, "Attribute %S is not found",
MeetingAttributeName(Attribute)));
return E_FAIL;
}
// allocate a BSTR to return.
*AttributeValue =
SysAllocString(m_Attributes[MeetingAttrIndex(Attribute)]);
if (*AttributeValue == NULL)
{
return E_OUTOFMEMORY;
}
LOG((MSP_INFO, "CConference::get %S : %S",
MeetingAttributeName(Attribute), *AttributeValue));
return S_OK;
}
HRESULT
CConference::GetSingleValueWstr(
IN OBJECT_ATTRIBUTE Attribute,
IN DWORD dwSize,
OUT WCHAR * AttributeValue
)
/*++
Routine Description:
Get the value of an attribute. copy the value to the buffer provided.
Arguments:
Attribute - the attribute id as defined in rend.idl
AttributeValue - a pointer to a buffer where the value will be copied to.
Return Value:
HRESULT.
--*/
{
LOG((MSP_INFO, "CConference::GetSingleValueWstr - entered"));
_ASSERTE(NULL != AttributeValue);
_ASSERTE(ValidMeetingAttribute(Attribute));
CLock Lock(m_lock);
if(!m_Attributes[MeetingAttrIndex(Attribute)])
{
LOG((MSP_ERROR, "Attribute %S is not found",
MeetingAttributeName(Attribute)));
return E_FAIL;
}
// copy the attribute value
lstrcpynW(
AttributeValue,
m_Attributes[MeetingAttrIndex(Attribute)],
dwSize
);
LOG((MSP_INFO, "CConference::get %S : %S",
MeetingAttributeName(Attribute), AttributeValue));
return S_OK;
}
HRESULT
CConference::SetSingleValue(
IN OBJECT_ATTRIBUTE Attribute,
IN WCHAR * AttributeValue
)
/*++
Routine Description:
Set the attribute value to a new string.
Arguments:
Attribute - the attribute id as defined in rend.idl
AttributeValue - the new value. If it is null, the value is deleted.
Return Value:
HRESULT.
--*/
{
LOG((MSP_INFO, "CConference::SetSingleValue - entered"));
if (!ValidMeetingAttribute(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 AttributeValue is NULL, the attribute is deleted.
if (!m_Attributes[MeetingAttrIndex(Attribute)].set(AttributeValue))
{
LOG((MSP_ERROR, "Can not add attribute %S",
MeetingAttributeName(Attribute)));
return E_OUTOFMEMORY;
}
LOG((MSP_INFO, "CConference::%S is set to %S",
MeetingAttributeName(Attribute), AttributeValue));
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// ITConference interface
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CConference::get_Name(BSTR * ppVal)
{
return m_pITConfBlobPrivate->GetName(ppVal);
}
STDMETHODIMP CConference::put_Name(BSTR pVal)
{
return m_pITConfBlobPrivate->SetName(pVal);
}
STDMETHODIMP CConference::get_Protocol(BSTR * ppVal)
{
return GetSingleValueBstr(MA_PROTOCOL, ppVal);
}
/*
*
* I've removed the following method from the interface because I don't plan
* to ever implement it.
*
STDMETHODIMP CConference::put_Protocol(BSTR newVal)
{
// currently not allowed to change this
// only IP Conference is supported
return E_NOTIMPL;
}
*
* The following are implemented but don't work. Again these are useless
* methods! Removed from the interface.
*
STDMETHODIMP CConference::get_ConferenceType(BSTR * ppVal)
{
return GetSingleValueBstr(MA_TYPE, ppVal);
}
STDMETHODIMP CConference::put_ConferenceType(BSTR newVal)
{
return SetSingleValue(MA_TYPE, newVal);
}
*/
STDMETHODIMP CConference::get_Originator(BSTR * ppVal)
{
return m_pITConfBlobPrivate->GetOriginator(ppVal);
}
STDMETHODIMP CConference::put_Originator(BSTR newVal)
{
return m_pITConfBlobPrivate->SetOriginator(newVal);
}
STDMETHODIMP CConference::get_AdvertisingScope(
RND_ADVERTISING_SCOPE *pAdvertisingScope
)
{
return m_pITConfBlobPrivate->GetAdvertisingScope(pAdvertisingScope);
}
STDMETHODIMP CConference::put_AdvertisingScope(
RND_ADVERTISING_SCOPE AdvertisingScope
)
{
return m_pITConfBlobPrivate->SetAdvertisingScope(AdvertisingScope);
}
STDMETHODIMP CConference::get_Url(BSTR * ppVal)
{
return m_pITConfBlobPrivate->GetUrl(ppVal);
}
STDMETHODIMP CConference::put_Url(BSTR newVal)
{
return m_pITConfBlobPrivate->SetUrl(newVal);
}
STDMETHODIMP CConference::get_Description(BSTR * ppVal)
{
return m_pITConfBlobPrivate->GetDescription(ppVal);
}
STDMETHODIMP CConference::put_Description(BSTR newVal)
{
return m_pITConfBlobPrivate->SetDescription(newVal);
}
STDMETHODIMP CConference::get_IsEncrypted(VARIANT_BOOL *pfEncrypted)
{
if ( IsBadWritePtr(pfEncrypted, sizeof(VARIANT_BOOL)) )
{
LOG((MSP_ERROR, "CConference::get_IsEncrypted : bad pointer passed in"));
return E_POINTER;
}
// We don't support encrypted streaming at all.
*pfEncrypted = VARIANT_FALSE;
return S_OK;
// ILS server (NT 5 beta 1) has IsEncrypted as a dword, this will be modified
// to a string afterwards at that time the code below should replace
// the current implementation
// return GetSingleValueBstr(MA_IS_ENCRYPTED, pVal);
}
STDMETHODIMP CConference::put_IsEncrypted(VARIANT_BOOL fEncrypted)
{
// We don't allow changes to this. See get_IsEncrypted.
return E_NOTIMPL;
// ILS server (NT 5 beta 1) has IsEncrypted as a dword, this will be modified
// to a string afterwards at that time the code below should replace the
// current implementation no need to notify the conference blob of the change
// return SetSingleValue(MA_IS_ENCRYPTED, newVal);
}
inline
DWORD_PTR TimetToNtpTime(IN time_t TimetVal)
{
return TimetVal + NTP_OFFSET;
}
inline
time_t NtpTimeToTimet(IN DWORD_PTR NtpTime)
{
return NtpTime - NTP_OFFSET;
}
inline HRESULT
SystemTimeToNtpTime(
IN SYSTEMTIME &Time,
OUT DWORD &NtpDword
)
{
_ASSERTE(FIRST_POSSIBLE_YEAR <= Time.wYear);
// fill in a tm struct with the values
tm NtpTmStruct;
NtpTmStruct.tm_isdst = -1; // no info available about daylight savings time
NtpTmStruct.tm_year = (int)Time.wYear - 1900;
NtpTmStruct.tm_mon = (int)Time.wMonth - 1; // months since january
NtpTmStruct.tm_mday = (int)Time.wDay;
NtpTmStruct.tm_wday = (int)Time.wDayOfWeek;
NtpTmStruct.tm_hour = (int)Time.wHour;
NtpTmStruct.tm_min = (int)Time.wMinute;
NtpTmStruct.tm_sec = (int)Time.wSecond;
// try to convert into a time_t value
time_t TimetVal = mktime(&NtpTmStruct);
if ( -1 == TimetVal )
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
// convert the time_t value into an NTP value
NtpDword = (DWORD) TimetToNtpTime(TimetVal);
return S_OK;
}
inline
HRESULT
NtpTimeToSystemTime(
IN DWORD dwNtpTime,
OUT SYSTEMTIME &Time
)
{
// if the gen time is WSTR_GEN_TIME_ZERO then,
// all the out parameters should be set to 0
if (dwNtpTime == 0)
{
memset(&Time, 0, sizeof(SYSTEMTIME));
return S_OK;
}
time_t Timet = NtpTimeToTimet(dwNtpTime);
// get the local tm struct for this time value
tm* pTimet = localtime(&Timet);
if( IsBadReadPtr(pTimet, sizeof(tm) ))
{
return E_FAIL;
}
tm LocalTm = *pTimet;
//
// win64: added casts below
//
// set the ref parameters to the tm struct values
Time.wYear = (WORD) ( LocalTm.tm_year + 1900 ); // years since 1900
Time.wMonth = (WORD) ( LocalTm.tm_mon + 1 ); // months SINCE january (0,11)
Time.wDay = (WORD) LocalTm.tm_mday;
Time.wDayOfWeek = (WORD) LocalTm.tm_wday;
Time.wHour = (WORD) LocalTm.tm_hour;
Time.wMinute = (WORD) LocalTm.tm_min;
Time.wSecond = (WORD) LocalTm.tm_sec;
Time.wMilliseconds = (WORD) 0;
return S_OK;
}
STDMETHODIMP CConference::get_StartTime(DATE *pDate)
{
LOG((MSP_INFO, "CConference::get_StartTime - enter"));
BAIL_IF_BAD_WRITE_PTR(pDate, E_POINTER);
DWORD dwStartTime;
HRESULT hr = m_pITConfBlobPrivate->GetStartTime(&dwStartTime);
BAIL_IF_FAIL(hr, "GetStartTime from blob");
// special case for permanent / unbounded conferences
// return the variant time zero. In the put_ methods this
// is also considered a special value. We will never
// actually use zero as a valid time because it is so
// far in the past.
if ( dwStartTime == 0 )
{
*pDate = 0; // special "unbounded" value
LOG((MSP_INFO, "CConference::get_StartTime - unbounded/permanent "
"- exit S_OK"));
return S_OK;
}
// break the generalized time entry into the year,
// month, day, hour and minute (local values)
SYSTEMTIME Time;
hr = NtpTimeToSystemTime(dwStartTime, Time);
if( FAILED(hr) )
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
DOUBLE vtime;
if (SystemTimeToVariantTime(&Time, &vtime) == FALSE)
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
*pDate = vtime;
LOG((MSP_INFO, "CConference::get_StartTime - exit S_OK"));
return S_OK;
}
STDMETHODIMP CConference::put_StartTime(DATE Date)
{
SYSTEMTIME Time;
if (VariantTimeToSystemTime(Date, &Time) == FALSE)
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
DWORD dwNtpStartTime;
if (Date == 0)
{
// unbounded start time
dwNtpStartTime = 0;
}
else if ( FIRST_POSSIBLE_YEAR > Time.wYear )
{
// cannot handle years less than FIRST_POSSIBLE_YEAR
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
else
{
BAIL_IF_FAIL(
SystemTimeToNtpTime(Time, dwNtpStartTime),
"getNtpDword"
);
}
// notify the conference blob of the change
HRESULT hr = m_pITConfBlobPrivate->SetStartTime(dwNtpStartTime);
BAIL_IF_FAIL(hr, "SetStartTime from to blob");
return S_OK;
}
STDMETHODIMP CConference::get_StopTime(DATE *pDate)
{
LOG((MSP_INFO, "CConference::get_StopTime - enter"));
BAIL_IF_BAD_WRITE_PTR(pDate, E_POINTER);
DWORD dwStopTime;
HRESULT hr = m_pITConfBlobPrivate->GetStopTime(&dwStopTime);
BAIL_IF_FAIL(hr, "GetStopTime from blob");
// special case for permanent / unbounded conferences
// return the variant time zero. In the put_ methods this
// is also considered a special value. We will never
// actually use zero as a valid time because it is so
// far in the past.
if ( dwStopTime == 0 )
{
*pDate = 0; // special "unbounded" value
LOG((MSP_INFO, "CConference::get_StopTime - unbounded/permanent "
"- exit S_OK"));
return S_OK;
}
// break the generalized time entry into the year,
// month, day, hour and minute (local values)
SYSTEMTIME Time;
hr =NtpTimeToSystemTime(dwStopTime, Time);
if( FAILED(hr) )
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
DOUBLE vtime;
if (SystemTimeToVariantTime(&Time, &vtime) == FALSE)
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
*pDate = vtime;
LOG((MSP_INFO, "CConference::get_StopTime - exit S_OK"));
return S_OK;
}
STDMETHODIMP CConference::put_StopTime(DATE Date)
{
SYSTEMTIME Time;
if (VariantTimeToSystemTime(Date, &Time) == FALSE)
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
DWORD dwNtpStopTime;
if (Date == 0)
{
// unbounded start time
dwNtpStopTime = 0;
}
else if ( FIRST_POSSIBLE_YEAR > Time.wYear )
{
// cannot handle years less than FIRST_POSSIBLE_YEAR
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
else
{
BAIL_IF_FAIL(
SystemTimeToNtpTime(Time, dwNtpStopTime),
"getNtpDword"
);
// determine current time
time_t CurrentTime = time(NULL);
if (dwNtpStopTime <= TimetToNtpTime(CurrentTime))
{
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
}
// notify the conference blob of the change
HRESULT hr = m_pITConfBlobPrivate->SetStopTime(dwNtpStopTime);
BAIL_IF_FAIL(hr, "SetStopTime from to blob");
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// ITDirectoryObject
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CConference::get_DialableAddrs(
IN long dwAddressTypes, //defined in tapi.h
OUT VARIANT * pVariant
)
{
BAIL_IF_BAD_WRITE_PTR(pVariant, E_POINTER);
BSTR *Addresses = new BSTR[1]; // only one for now.
BAIL_IF_NULL(Addresses, E_OUTOFMEMORY);
HRESULT hr;
switch (dwAddressTypes) // ZoltanS fix
{
case LINEADDRESSTYPE_SDP:
hr = UpdateConferenceBlob(m_pIUnkConfBlob);
if ( FAILED(hr) )
{
LOG((MSP_ERROR, "CConference::get_DialableAddrs - "
"failed to update blob attribute from the blob object"));
}
else
{
hr = GetSingleValueBstr(MA_CONFERENCE_BLOB, &Addresses[0]);
}
break;
default:
hr = E_FAIL; // just return 0 addresses
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 CConference::EnumerateDialableAddrs(
IN DWORD dwAddressTypes, //defined in tapi.h
OUT IEnumDialableAddrs ** ppEnumDialableAddrs
)
{
BAIL_IF_BAD_WRITE_PTR(ppEnumDialableAddrs, E_POINTER);
BSTR *Addresses = new BSTR[1]; // only one for now.
BAIL_IF_NULL(Addresses, E_OUTOFMEMORY);
HRESULT hr;
switch (dwAddressTypes) // ZoltanS fix
{
case LINEADDRESSTYPE_SDP:
hr = UpdateConferenceBlob(m_pIUnkConfBlob);
if ( FAILED(hr) )
{
LOG((MSP_ERROR, "CConference::EnumerateDialableAddrs - "
"failed to update blob attribute from the blob object"));
}
else
{
hr = GetSingleValueBstr(MA_CONFERENCE_BLOB, &Addresses[0]);
}
break;
default:
hr = E_FAIL; // just return 0 addresses
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 CConference::GetAttribute(
IN OBJECT_ATTRIBUTE Attribute,
OUT BSTR * ppAttributeValue
)
{
if (Attribute == MA_CONFERENCE_BLOB)
{
BAIL_IF_FAIL(
UpdateConferenceBlob(m_pIUnkConfBlob),
"update blob attribute from the blob object"
);
}
return GetSingleValueBstr(Attribute, ppAttributeValue);
}
STDMETHODIMP CConference::SetAttribute(
IN OBJECT_ATTRIBUTE Attribute,
IN BSTR pAttributeValue
)
{
// this function is never called in the current implementation.
// However, it might be useful in the future.
return SetSingleValue(Attribute, pAttributeValue);
}
STDMETHODIMP CConference::GetTTL(
OUT DWORD * pdwTTL
)
{
LOG((MSP_INFO, "CConference::GetTTL - enter"));
//
// Check arguments.
//
BAIL_IF_BAD_WRITE_PTR(pdwTTL, E_POINTER);
//
// Get the stop time from the conference blob.
//
DWORD dwStopTime;
HRESULT hr = m_pITConfBlobPrivate->GetStopTime(&dwStopTime);
BAIL_IF_FAIL(hr, "GetStopTime from blob");
//
// If the blob has zero as the stop time, then this conference does not
// have an explicit end time. The RFC calls this an "unbounded" session
// (or a "permanent" session if the start time is also zero. In this
// case we use some very large value (MAX_TTL) as the TTL.
//
if ( dwStopTime == 0 )
{
*pdwTTL = MAX_TTL;
LOG((MSP_INFO, "CConference::GetTTL - unbounded or permanent "
"conference - exit S_OK"));
return S_OK;
}
//
// Determine the current NTP time.
//
time_t CurrentTime = time(NULL);
DWORD dwCurrentTime = (DWORD) TimetToNtpTime(CurrentTime);
//
// Error if the current time is later than the conference stop time.
//
if ( dwStopTime <= dwCurrentTime )
{
LOG((MSP_ERROR, "CConference::GetTTL - bounded conference - "
"current time is later than start time - "
"exit RND_INVALID_TIME"));
return HRESULT_FROM_ERROR_CODE(RND_INVALID_TIME);
}
//
// Return how much time from now until the conference expires.
//
*pdwTTL = dwStopTime - (DWORD) TimetToNtpTime(CurrentTime);
LOG((MSP_INFO, "CConference::GetTTL - bounded conference - "
"exit S_OK"));
return S_OK;
}
typedef IDispatchImpl<ITDirectoryObjectConferenceVtbl<CConference>, &IID_ITDirectoryObjectConference, &LIBID_RENDLib> CTDirObjConference;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// CConference::GetIDsOfNames
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
STDMETHODIMP CConference::GetIDsOfNames(REFIID riid,
LPOLESTR* rgszNames,
UINT cNames,
LCID lcid,
DISPID* rgdispid
)
{
LOG((MSP_TRACE, "CConference::GetIDsOfNames[%p] - enter. Name [%S]",this, *rgszNames));
HRESULT hr = DISP_E_UNKNOWNNAME;
//
// See if the requsted method belongs to the default interface
//
hr = CTDirObjConference::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
if (SUCCEEDED(hr))
{
LOG((MSP_TRACE, "CConference:GetIDsOfNames - found %S on CTDirObjConference", *rgszNames));
rgdispid[0] |= IDISPDIROBJCONFERENCE;
return hr;
}
//
// If not, then try the CDirectoryObject base class
//
hr = CDirectoryObject::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
if (SUCCEEDED(hr))
{
LOG((MSP_TRACE, "CConference::GetIDsOfNames - found %S on CDirectoryObject", *rgszNames));
rgdispid[0] |= IDISPDIROBJECT;
return hr;
}
LOG((MSP_ERROR, "CConference::GetIDsOfNames[%p] - finish. didn't find %S on our iterfaces",*rgszNames));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// CConference::Invoke
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
STDMETHODIMP CConference::Invoke(DISPID dispidMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS* pdispparams,
VARIANT* pvarResult,
EXCEPINFO* pexcepinfo,
UINT* puArgErr
)
{
LOG((MSP_TRACE, "CConference::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 IDISPDIROBJCONFERENCE:
{
hr = CTDirObjConference::Invoke(dispidMember,
riid,
lcid,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr
);
LOG((MSP_TRACE, "CConference::Invoke - ITDirectoryObjectConference"));
break;
}
case IDISPDIROBJECT:
{
hr = CDirectoryObject::Invoke(dispidMember,
riid,
lcid,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr
);
LOG((MSP_TRACE, "CConference::Invoke - ITDirectoryObject"));
break;
}
} // end switch (dwInterface)
LOG((MSP_TRACE, "CConference::Invoke[%p] - finish. hr = %lx", hr));
return hr;
}
// eof
Reference in a new issue Copy permalink